
Building albertoduran.com
How albertoduran.com is built as a static-first Astro platform that compiles MDX, diagrams, and charts into inspectable files.
Writing about technical challenges, life lessons, and the things that keep me overthinking. Like a blog, but with a cooler name.

How albertoduran.com is built as a static-first Astro platform that compiles MDX, diagrams, and charts into inspectable files.

A practical look at a serverless AWS video pipeline that turns private recordings into HLS playback through MediaConvert, S3, Lambda, EventBridge, and CloudFront.

Oracle trades at a deep discount to its intrinsic value despite high debt and negative free cash flow from AI infrastructure investments

How three standalone tools, the Equity Valuation Engine, Equilyze, and Pressroom, turn a stock ticker into a finished article.

Build a local LangChain chat project with Ollama, from environment setup to a working terminal conversation loop.

Years of conservative investing led me to build a Python engine for studying company valuations with visible assumptions, model checks, and limits.

One missed bargain became MLScraper, a Python service that watches four stores, preserves price history, and treats unreliable pages with care.

A unified benchmarking pipeline that deploys Online Boutique locally, on GCP, and on AWS, collects metrics, persists cloud history to BigQuery, and serves results in Grafana and a portable HTML dashboard.

A spec-driven blueprint for building infrastructure intelligence with LangGraph, Prometheus, and Claude Sonnet. Learn how seven markdown files become a working AI agent.

A complete walkthrough for setting up a Google Cloud account, configuring GitHub Actions OIDC auth, and running your first automated benchmark with SiliconBoutique.

An academic writing platform introduced me to software architecture and placed second among 40 projects after I built it on my own.

Writing an article is really compiling one. The path a candidate MDX file takes from schema, through policy and routing, to a rendered page.

The live Zod schema every publication satisfies, the glob that hides partials, and the one field the schema accepts but the page never shows.

Why an author writes a fenced block instead of importing a component, how parity is guaranteed, and when to reach for the component after all.

The manifest is where publication policy lives. Draft scoping, the invariants a vault must satisfy, image inheritance, ordering, and the read-time formula.

The Markdown processor, why the fence integration registers before mdx, how Markdown elements become components, and how code gets two themes.

How a catch-all route turns published entries into a finite list of pages, and the shell of sidebars, dock, and overlays that surrounds every article.

Why albertoduran stopped owning its UI kit and render engines, and how it now consumes them as two versioned packages.

The honest counterweight to the extraction story: duplicated CSS, git-ref versioning, source-shipped compilation, and two bugs only the real build found.

The integration that turns code fences into rendered output, why it registers before mdx, and why it no longer renders Mermaid itself.

Extraction worked because three decisions moved from the packages to the app: what publishes, where bytes are cached, and who renders.

The four component families, the pure logic layer that keeps fences and components identical, and why icons ship as props.

How a package that was meant to stay a dependency-free leaf deliberately reversed course and absorbed build-time rendering.

What the app still owns of its look, what bloomwright-ui now owns, and where the line between them falls after the UI kit moved out.

Consuming an unstable third-party source during the build, validating it like any other content, and letting the browser finish the one job the build cannot.

One global stylesheet imported in ten numbered stages, the DaisyUI parts it opts into, and the duplicated partials the extraction left behind.

The surfaces outside the journal: project landing pages that act as vault front doors, and the recruiter-facing profile built from typed data.

Every browser enhancement improves a baseline that already renders. The custom elements that do it now ship from two repositories, and why failures stay local.

The app-owned reading experience: heading tracking with sticky offsets and page edges, the vault explorer tree, and previous-next pagination.

DaisyUI 5 OKLCH themes and semantic tokens, and the three separate moments a theme has to be correct, each owned by a different layer.

The system behind the site: what each repository owns, what is left in the app, and the single static artifact they all serve.

How the static build reaches Cloudflare Workers Static Assets, the caching and security headers it ships, and where configuration ends and platform capability begins.

The app got smaller when the packages left. A tour of what remains in src, and one publication change traced through the boundaries that stayed.

The Node 22 devcontainer, how github dependencies resolve, and what a source-shipped package asks of the workspace that consumes it.

How the site turns diagrams and charts into static SVG at build time, and the rule that decides which tool draws what.

Every chart family rendered in a real article, with a note on the question each one answers, so an author can choose by looking at output.

How an ECharts options object becomes a server-rendered SVG at build time, how it is cached and emitted, and the five ways it can wake up.

The provider chain that keeps a render outage from ever crashing a build, and the fixture mode that keeps tests offline.

The build integration that finds diagrams, batches them, checks a cache, renders the misses, and writes themed SVG assets.

The full round trip from the build to the Cloudflare Worker and back, what happens inside while the build waits, and two live mismatches.

The HAST pass that strips scripts, rewrites ids, scopes CSS, and merges light and dark into one asset, plus the palette that survives the network.

The site deploys to Cloudflare, so why is there a second Cloudflare thing? The four-part answer, and the honest counterweights.

Learn how historical signals, configured limits, and scenario policy become Bear, Base, and Bull paths without pretending to predict.

Match DCF, multiples, dividends, assets, and reverse DCF to the financial shape of a business before trusting any estimate.

Build a discounted cash-flow valuation, inspect its sensitivity, and reverse the calculation to understand market-implied expectations.

Trace the architecture behind data fields, diagnostics, suitability, valuation managers, CLI output, JSON, and tests before adding features.

Install the equity valuation engine, run one ticker, and learn to read suitability checks, scenarios, skipped models, and JSON.

Compare P/E, EV/EBITDA, P/S, ROE, DDM, and NAV through independent examples, and learn why every model needs its own guardrails.

Interpret scenario rows, skipped models, the equal-weight composite, model dispersion, and JSON without turning output into a target price.

Follow provider data into StockMetrics, learn what missing-value diagnostics preserve, and see which gaps can still mislead a model.

Follow one illustrative Amazon Mexico watch from YAML and URL preview to saved product history, runtime health, and a later price alert.

Learn how MLScraper chooses HTTP or browser fetching, protects history after incomplete pages, and slows the right scope after failures.

Learn how MLScraper turns stable job identity and provider options into validated store routes, predictable storage paths, and safe previews.

Run MLScraper locally, diagnose health and saved state, exercise its offline tests, and extend the provider contract without runtime leaks.

Follow one stable product identifier through updates, temporary absence, recovery, JSON persistence, and MLScraper price-drop alerts.

Compare four ecommerce page formats and learn how MLScraper isolates store-specific URLs and parsing behind one product contract.

See how FastAPI starts MLScraper, provider loops share concurrency safely, and health turns background work into observable state.

A detailed look at how Sin Pluma's React SPA is structured: Redux state, HOC-based auth guards, Axios interceptors, Slate.js rich text editor, and backend service integration patterns.

A detailed walkthrough of every service in the Sin Pluma system, how Docker networks isolate them, the data flows behind key operations, and the architectural strengths and constraints.

How Sin Pluma's Flask API is structured: the app factory pattern, blueprint organization, full endpoint inventory, Marshmallow validation, and integrations with MySQL, Redis, and MinIO.

How Sin Pluma bootstraps a three-node MySQL InnoDB Cluster, handles automatic failover, manages the schema, and what production hardening looks like beyond the demo environment.

A detailed walkthrough of Sin Pluma's JWT implementation: token structure, full lifecycle, the Redis blacklist, the Axios refresh queue, storage trade-offs, and security best practices.