UTxO Timeline Graph: Visual Time-Travel Debugging for Devs

[Proposal setup] Proposal title

Please provide your proposal title

UTxO Timeline Graph: Visual Time-Travel Debugging for Devs

[Proposal Summary] Budget Information

Enter the amount of funding you are requesting in ADA

100000

[Proposal Summary] Time

Please specify how many months you expect your project to last

8

[Proposal Summary] Translation Information

Please indicate if your proposal has been auto-translated

No

Original Language

en

[Proposal Summary] Problem Statement

What is the problem you want to solve?

UTxO debugging is slow and opaque: current explorers focus on transactions and lack time-travel views. Devs can’t easily see which UTxOs were added/removed/changed or export clear visuals for docs

[Proposal Summary] Project Dependencies

Does your project have any dependencies on other organizations, technical or otherwise?

No

Describe any dependencies or write 'No dependencies'

No dependencies

[Proposal Summary] Project Open Source

Will your project's outputs be fully open source?

Yes

License and Additional Information

Apache 2.0

[Theme Selection] Theme

Please choose the most relevant theme and tag related to the outcomes of your proposal

UTXO

[Campaign Category] Category Questions

Mention your open source license and describe your open source license rationale.

We will choose a license that lets anyone use and improve the tool freely.

• License: Apache-2.0 (OSI-approved)
• Why this license fits our project goals: permissive, safe for companies and community; allows reuse in other tools without legal friction; includes a patent grant.
• Contributions: simple rules (DCO + Contributor Covenant) so people can send pull requests easily.
• Goals: maximize adoption across wallets, SDKs, and developer tools.

How do you make sure your source code is accessible to the public from project start, and people are informed?

We will be public on Day 1 and keep everyone informed.

• Day-1 GitHub: repo with LICENSE, README, ROADMAP, CONTRIBUTING, SECURITY, issue templates, and a public project board.
• Process: regular commits, pull requests, semantic version tags, automated tests
• Updates: release notes, a small status page (uptime/changes), and monthly Catalyst progress posts with links.

How will you provide high quality documentation?

We will ship clear docs for users and developers.

• Docs site: Docusaurus + Markdown, linked from the repo.
• Content: Quickstart, setup (self-host with Terraform), user guide, API (OpenAPI + Swagger UI), SDK reference (TypeDoc), adapter guides, "how to read the timeline," examples.
• Quality: docs versioned per release; links/code checked in CI; a simple Proof-of-Achievement checklist.

[Your Project and Solution] Solution

Please describe your proposed solution and how it addresses the problem

Most Cardano explorers show long lists of transactions. They don't tell the story of what changed and when. That makes debugging slow and writing reports painful. Our solution is a simple web app that turns this into a timeline you can move through (like scrubbing a video) so you can see what was added, removed, or changed at each step and export clean pictures for reports and audits.

What we will build

• One web app, open-source from day one: You paste a target (a contract, policy, or normal address). The app gathers only the relevant activity and builds a timeline of moments.
• A visual "state at a moment" view: At any point in the timeline you see a graph of the state around your target (boxes and arrows—no code required).
• Interactive time-travel: Click Previous/Next or drag a slider to move through time and watch the state change step by step.
• Export-ready: With one click, download images (PNG/SVG) or diagram text you can paste into docs and audits.

How it fixes the problem

• Shows the story, not just IDs: instead of hunting through many pages of transaction IDs, you see a clear picture of "what changed here". This saves hours and prevents mistakes.
• Color highlights make changes obvious: we use simple colors: green = added, red = removed, yellow = changed (consumed then replaced). You don’t need to guess, your eyes do the work.
• Step or scrub to key moments: You can jump to important points (first deposit, mint, close), or scrub smoothly to explore. This makes both debugging and teaching easy.
• One-click exports create proof: Clean images and diagram text can go straight into READMEs, proposals, and Proof-of-Achievement reports, no design software required.

Why we approach it this way

• We prepare data in advance so the UI is fast: The server makes snapshots ("frames") and differences ("what changed" ahead of time. That’s why the slider feels smooth instead of laggy.
• Open from day one, with a public site after launch: Code on GitHub under Apache-2.0; anyone can read, reuse, and self-host. We will also host it free for 12 months after v1.0 so the community can use it immediately.
• Easy to run elsewhere: Clear docs and cloud templates let other teams deploy their own copy in a few steps, useful for privacy or heavy workloads.

Who this will engage

• Developers: find the exact step where a mistake happened, confirm a fix, and export a picture for the pull request.
• Auditors/Reviewers: turn a complex flow into a few clear images and a short timeline for reports and Catalyst PoA.
• Educators/Newcomers: learn Cardano's "consume and produce" logic by seeing it happen over time.
• Project owners: add trustworthy diagrams to proposals and documentation without hiring a designer.

What makes it unique

• Built around time, not just lists: It’s a timeline for state changes, not just a pile of transactions.
• Live "what changed" overlay: Adds/Removes/Changes are highlighted at every step, no mental math.
• Docs-ready exports: Images and diagram text that look good and are simple to reuse.
• Open, self-hostable design: Anyone can run it, check it, and improve it, no vendor lock-in or paywall.

How we'll prove our impact

• Adoption you can see: projects that include our exported images/timelines in their docs; GitHub stars and forks.
• Usage you can count: number of targets explored, timeline moves, and images exported.
• On-chain activity processed: how many targets, transactions, and timeline frames we handled.
• Good experience numbers: most timeline moves finish in under 0.25 second on normal projects; 99%+ export success; 99%+ weekly uptime.

Why this matters to Cardano

• Faster building, fewer bugs: Clear visuals help teams spot and fix problems early.
• Stronger trust in reports: Reviewers and the community can understand flows at a glance.
• Better learning curve: New people grasp UTxO by seeing it, not decoding jargon.
• Shared public good: The tool is open-source and free to use online for a year, with a simple path to keep it alive through self-hosting.

Risks we've planned for:

• Huge histories can be heavy: we paginate and cache; we also pre-index a few popular public examples so everyone can try it instantly.
• Third-party rate limits: the app supports multiple data providers; teams can run their own node if needed.
• Small chain rollbacks (normal event): we quietly refresh recent steps and show a small notice if a fresh step changed.

We turn confusing blockchain activity into a clear, visual timeline you can explore and export. This makes building, reviewing, and teaching on Cardano faster and easier for everyone. Because it’s open-source and hosted for a year after launch, the community gets real value right away, and can keep that value going by self-hosting in the future.

[Your Project and Solution] Impact

Please define the positive impact your project will have on the wider Cardano community

Our tool turns long, confusing transaction lists into a simple, visual timeline of what changed and when. This helps people build safer apps, review projects with confidence, and teach Cardano more easily. It is open-source, free to use online for 12 months after launch, and simple to self-host forever.

How this brings value to the Cardano community

• Developers ship faster with fewer bugs: they can see adds/removes/changes in seconds instead of chasing tx links.
• Auditors, reviewers, and project teams explain clearly: clean images and timelines make reports and Proof-of-Achievement easier to trust.
• Educators and newcomers learn faster: the timeline shows how Cardano changes step by step, not just as a wall of hashes.
• Shared, reusable visuals: projects across the ecosystem can use the same clear pictures and diagrams in docs, PRs, and audits.
• Open and durable: free public site for a year; open code and guides so anyone can run it long-term.

How we will measure impact (quantitative numbers)

• Adoption:
  • ≥ 5 projects using our exported images/diagrams in their docs or PoA.
  • ≥ 100 GitHub stars, ≥ 10 forks.
• Usage:
  • ≥ 300 distinct targets explored in year one.
  • Counts of timelines viewed and images/diagrams exported.
• On-chain–derived (from what we index):
  • Number of targets, transactions, and snapshots (frames) processed.
• Reliability & speed:
  • Most slider moves ≤ 0.25s (on cached, mid-sized histories).
  • Export success ≥ 99%.
  • Site uptime ≥ 99% per week.

How we will measure impact (qualitative feedback)

• In-app quick survey (3 short questions): “Did this save you time?”, “Was the timeline clear?”, “What’s missing?”
• Short case studies (2–3 teams) describing time saved and clarity gained, shared as simple blog posts in the repo.
• Public issue labels (“impact”, “feature request”) to track common needs and improve the tool.

How and with whom we will share the outputs

• Public webapp (no login for demos) with a status page showing uptime and recent releases.
• Open GitHub repo (Apache-2.0), plus Docker/Terraform so anyone can self-host.
• Docs site with step-by-step guides, copy-paste examples, and short GIFs.
• Monthly updates: release notes, usage numbers, and links to new exports/case studies—posted to GitHub and Catalyst updates.
• Pre-indexed demo targets so reviewers, developers, newcomers, and educators can try it in seconds.

Success looks like this: more Cardano projects fix problems faster, write clearer reports, and teach UTxO with pictures instead of guesswork. Because the tool is open-source and hosted for a year after launch—with a simple path to self-hosting—the benefits are immediate, shared, and long-lasting for the whole community.

[Your Project and Solution] Capabilities & Feasibility

What is your capability to deliver your project with high levels of trust and accountability? How do you intend to validate if your approach is feasible?

We are a small, full-time team with clear roles and a simple plan. We will work in public, show proof at each step, and keep costs under control. Our goal is to make it easy for anyone to see progress, check results, and trust how funds are used.

Why we are capable of delivering

• Team skills fit the job
  • Manh Nguyen (lead): backend + AWS cloud + Cardano (Plutus/Marlowe). Builds the engine, frames/diffs, and the cloud setup.
  • Hoang Nguyen: frontend (React/Next.js). Builds the viewer, slider, and exports.
  • Ngan Nguyen: UX/UI. Makes the timeline simple to use and easy to read.
  • Thuy Hoang: test automation. Writes tests, checks performance, gathers evidence.
• Past experience
  • Years of professional software work, managing teams, and running apps on AWS.
  • Completed Cardano-focused learning (Plutus Pioneer, Haskell, Cardano courses).
• Clear ownership
  • Each milestone lists who does what. We avoid overlap and keep decisions fast.

Why the plan is feasible

• Right-sized scope: We do one thing well - make snapshots and differences, then show them in a timeline with export buttons. No extra features (SDKs, wallets, etc.)
• Eight-month plan, five milestones: Each milestone has outputs, acceptance rules, and evidence (release tags, example files, videos, performance numbers)
• Performance budget: Most slider moves should finish in under 0.25 second on normal targets (up to ~1k transactions). We keep the app fast by preparing data on the server first
• Hosting after launch: We fund 12 months of free public hosting so the community can use the tool right away while still being free to self-host

How we ensure trust & accountability

• Public from Day 1
  • GitHub repo with Apache-2.0 license, README, roadmap, contributing, security notes, issue templates.
• Release discipline
  • Monthly releases with change logs; version tags; links to example outputs.
  • All code changes go through pull requests with checks (tests, lints).
• Milestone proof
  • For each milestone we publish: outputs, acceptance checklists, links (repo, artifacts), and a short demo clip.
• Close-out deliverables
  • Project Close-out Report and Close-out Video submitted in the Catalyst Milestone Module at v1.0.

How we will manage funds properly

• Milestone-based spending
  • Funds are planned per milestone. We only spend on the tasks listed (people, cloud, testing tools).
• Public ledger
  • A simple ledger.csv in the repo shows each expense category (personnel, AWS, tools). We publish a short monthly cost summary.
• Cloud cost controls
  • AWS Budgets/alerts, tagged resources, and "scale-to-zero" where possible. We start small and only scale if usage grows.
• No lock-in or prepay
  • On-demand services; short pilots before any heavier compute (e.g., a self-hosted node). Everything is reproducible via Terraform.
• Compliance
  • We follow Catalyst reporting rules, including the Milestone Module and final close-out requirements.

Key risks and how we reduce them

• Very large histories: We paginate and cache. We also pre-index a few public demo targets. For very heavy targets, we guide teams to self-host.
• Third-party API limits: We use modular adapters and can run our own node (Ogmios + Kupo) if needed.
• Front-end complexity: We keep the viewer simple and move heavy work to the server. If a target is huge, we smoothly fall back to "step" mode.

We can deliver this on time because our plan is simple, our team is full-time, and we stick to clear checkpoints. From the first week, our work is public: you can see the code, the to-do list, and what we finished. Every 6–8 weeks we publish a new version with proof screenshots, a short demo video, and easy numbers (how fast it runs, how many examples work). A public status page shows if the site is up and healthy. We handle money the same way: a simple public ledger and monthly cost notes so you can see where funds go. If anything threatens the schedule, we cut non-essential extras and protect the core promise: a fast, clear UTxO timeline with exports. At the end, we submit a Close-out Report and Video and cover 12 months of free hosting so the community can use the tool right away. This open, steady, and honest approach makes the project trustworthy and accountable

[Milestones] Project Milestones

Milestone Title

Public repo, architecture & “Hello Graph”

Milestone Outputs

1. Public GitHub repo with license, readme, roadmap, contributing and security notes, issue templates, and a project board.
2. Base code layout for core, API, workers, viewer, and adapters; basic database setup and Docker files.
3. MSmall indexer that processes a sample (≥ 50 tx) and creates a single static graph image.
4. Automated build/test, basic cloud templates, and a v0.1.0 release with docs v0.1

Acceptance Criteria

1. Repo is public, licensed Apache-2.0, and shows ≥5 starter issues and a live CI badge.
2. Project builds locally; the database migration runs; a local Docker setup starts API and viewer.
3. A sample target produces a PNG + Mermaid diagram checked into /examples.
4. CI passes, cloud template runs without errors, and a tagged v0.1.0 release exists with release notes.

Evidence of Completion

1. Repo link and screenshots of the project board and CI
2. Folder tree, migration files, Docker files, and a screenshot of the local app running
3. The exported PNG/Mermaid in the repo plus logs showing ≥50 tx processed
4. CI logs, cloud template output, and the v0.1.0 release page

Delivery Month

2

Cost

18000

Progress

20 %

Milestone Title

Snapshots & server-made differences

Milestone Outputs

1. Indexing that makes frames (snapshots over time) and differences (what was added/removed/changed).
2. First data adapter (Kupo or a public API) with settings and docs; caching so back/forward is fast.
3. Simple “previous/next” buttons; export Mermaid/DOT/PNG via the API.
4. Docs that explain frames/diffs, plus test cases that check the math.

Acceptance Criteria

1. We index a target with ≥ 500 transactions and produce frames and diffs without errors
2. Going back/forward on cached data feels quick (about half a second on the sample).
3. The stepper walks through ≥50 frames; exports work for at least 3 frames
4. ≥ 10 tests show adds/removes/changes are tagged correctly; docs explain how this works.

Evidence of Completion

1. A short report with totals for frames/diffs
2. Timing screenshots and simple config examples.
3. Exported files committed under /examples
4. CI test output and a v0.2.x release with notes.

Delivery Month

4

Cost

24000

Progress

40 %

Milestone Title

Interactive slider, bookmarks & polished exports

Milestone Outputs

1. A slider you can drag, with a live color overlay showing adds/removes/changes; arrow keys and jump-to slot/tx.
2. Bookmarks auto-generated for key moments (first deposit, mint, close, datum change, large bundle) and filters (by policy, address, value, size)
3. Clean PNG/SVG exports and a simple Markdown timeline (frames N to M) with small diff tables.
4. Second data adapter (Ogmios), plus tests that make sure exported pictures match the data.

Acceptance Criteria

1. On normal projects (up to ~1k transactions), most slider moves finish in under 0.25 second; overlays match server diffs on ≥ 20 frames
2. At least 5 bookmark rules enabled and visible; filters clearly reduce what’s shown
3. PNG/SVG match the on-screen view for ≥ 10 frames; one Markdown timeline spans ≥ 10 frames.
4. ≥12 stable tests pass the same way with both adapters; docs updated.

Evidence of Completion

1. A small performance report with charts and a short screen recording of smooth dragging
2. Screenshots showing bookmarks and filters; sample configs in the repo.
3. Exported files and the Markdown timeline in /examples.
4. CI logs for the tests and a v0.3.x release with notes.

Delivery Month

6

Cost

24000

Progress

70 %

Milestone Title

Public hosting & operations

Milestone Outputs

1. Public website on AWS with fair-use rate limits, a job queue, and a status page (uptime/latency/releases)
2. Three pre-indexed demo targets (contract / policy / address) that open fast; cloud budgets/alerts; basic dashboards for logs and metrics
3. An ops guide (how we scale, handle rollbacks, back up/restore, and tune the database)

Acceptance Criteria

1. The site is live with ≥ 99% uptime across 2 weeks; the status page shows health and last release
2. All demo targets open the first view in under 3 seconds and support the slider and exports; rate limits enforce fair use
3. Budgets/alerts are active; dashboards exist; the ops guide is published.

Evidence of Completion

1. Status page link and screenshots for uptime and latency.
2. Live URL, a short video of sub-3-second loads and working exports, and a log showing rate-limit behavior.
3. Screenshots of budgets/alerts and dashboards; the ops guide in the repo; a v0.4.x release

Delivery Month

7

Cost

18000

Progress

90 %

Milestone Title

Release v1.0, examples & Final Close-out Report

Milestone Outputs

1. v1.0.0 release and final docs (Quickstart, guides, API/SDK, export cookbook)
2. Two public example repos that show how to embed a frame and export pictures; short tutorial GIFs or a video
3. Project Close-out Report.
4. Project Close-out Video.

Acceptance Criteria

1. v1.0 tagged, docs live, and examples/links checked automatically
2. Two example repos are public and linked; at least 1 tutorial video is published
3. Close-out Report submitted in the Milestone Module with KPIs and a budget table matching 100,000 ₳.
4. Close-out Video submitted (under 5 minutes, clear audio/captions) with a public link.

Evidence of Completion

1. Release page for v1.0.0, live docs URL, and CI logs for doc checks
2. Links to example repos and tutorial media
3. Link to Close-out Report file.
4. Public video URL (e.g., YouTube unlisted).

Delivery Month

8

Cost

16000

Progress

100 %

[Final Pitch] Budget & Costs

Please provide a cost breakdown of the proposed work and resources

This budget funds an 8-month build by a full-time, four-person team, and then 12 months of free public hosting after v1.0. Spend concentrates on open-source engineering for the interactive UTxO timeline debugger, with a clearly ring-fenced operations reserve so the community can rely on the hosted webapp for a full year.

Breakdown by category

Personnel — full-time team delivering v1.0 (77,000 ₳)

• Manh Nguyen - Leader / Plutus / Cloud / Backend: 45,000 ₳
  • Architecture; indexing/frames/diffs; backend services; AWS infra; performance & security notes; release engineering; close-out deliverables.
• Hoang Nguyen - Frontend & Off-chain: 16,000 ₳
  • Next.js viewer; interactive slider; diff overlay; bookmarks/filters; SDK wiring; rendering performance.
• Ngan Nguyen — UX/UI: 9,000 ₳
  • Timeline UX; information design; accessibility; export UX; design system & specs.
• Thuy Hoang — Automation Testing: 7,000 ₳
  • Test plans; golden-file & load tests; CI gates; evidence capture for milestones and close-out.

Cloud & Operations — includes 12 months after completion (18,000 ₳)

• Post-completion production hosting (Months +1 to +12): 12,000 ₳ (~1,000 ₳/mo)
  • S3 + CloudFront (site & artifacts), ECS Fargate (API/workers), RDS Postgres (metadata), SQS (jobs), CloudWatch (logs/metrics), Route53/ACM (DNS/TLS)
  • Disbursement note: The 12,000 ₳ hosting reserve is allocated at M5 and reported monthly after v1.0
• Development & staging during build (Months 1–8): 4,000 ₳ (~500 ₳/mo)
  • Lower-capacity envs for testing/demos prior to v1.0
• Egress/artifact buffer & optional node pilot: 2,000 ₳
  • Covers export downloads, spikes, and a short EC2 pilot for cardano-node + Ogmios + Kupo if usage warrants.

QA / Performance / Security Tooling (3,000 ₳)

• Load-testing & data generation: 1,000 ₳ (synthetic 250/500/1k-tx histories).
• Static analysis / SBOM / security scans: 800 ₳ (dependency audit in CI).
• Golden files & artifact storage: 600 ₳ (deterministic export checks).
• Tutorial & close-out media tools: 600 ₳ (recording/editing, captions)

Contingency (2,000 ₳)

• ~2% buffer for AWS spikes (egress/storage), brief compute bursts, or adapter maintenance

Breakdown by milestone

• M1 (18,000 ₳): Personnel 14,000; Ops 3,500; QA 300; Cont. 200.
• M2 (24,000 ₳): Personnel 18,500; Ops 4,500; QA 700; Cont. 300.
• M3 (24,000 ₳): Personnel 18,500; Ops 4,500; QA 700; Cont. 300.
• M4 (18,000 ₳): Personnel 14,500; Ops 3,000; QA 300; Cont. 200.
• M5 (16,000 ₳): Personnel 11,500; Ops 2,500 (allocates the 12,000 ₳ post-completion hosting reserve); QA 1,000; Cont. 1,000

Third-party products/services

• AWS (on-demand): S3/CloudFront, ECS Fargate, RDS Postgres, SQS, CloudWatch, Route 53/ACM. No long-term commitments; scale per usage.
• Cardano access layer: Start with third-party API credits for speed; pilot self-hosted node with Ogmios + Kupo on EC2 if demand justifies. Both paths documented.
• Tooling: All development tools are open-source (Node/TypeScript, Next.js, Docusaurus, Mermaid, Graphviz). No proprietary licenses needed.

Budget governance (cost control & transparency)

• AWS Budgets/alerts, tagged resources, autoscaling/scale-to-zero; monthly public cost summaries.
• Public ledger.csv reconciles milestone disbursements to actuals; variances explained.
• Status page publishes uptime/latency; releases include benchmark snapshots and artifact links.

This allocation puts most ada into full-time engineering and a year of post-completion hosting, ensuring the tool is delivered, proven, and freely usable. With transparent ledgers, milestone-tied spend, and explicit hosting reserves, the community sees exactly how funds become lasting developer infrastructure that anyone can use, fork, and self-host

[Final Pitch] Value for Money

How does the cost of the project represent value for the Cardano ecosystem?

This proposal converts 100,000 ₳ into durable, open-source developer infrastructure plus 12 months of free public hosting after v1.0. The spend is concentrated on shipping a high-impact feature set (interactive timeline with time-travel diffs and exports), with lean operations and transparent cost controls. Reviewers and the community can see, use, fork, and independently host the outputs from day one.

Why the ask is reasonable

• Funds both the 8-month build and 12 months of post-completion hosting, avoiding the common gap where tools ship but aren’t accessible.
• Small, focused team keeps overhead low; the majority of funds go directly to engineering outputs and verifiable artifacts.
• Scope is medium complexity with a clear MVP to v1 path, reducing risk and rework.

High leverage from open source

• Apache-2.0 license maximizes reuse in wallets, SDKs, dashboards, and audits—no vendor lock-in or licensing costs.
• IaC + Docker enable cheap community mirrors and long-term sustainability beyond the grant.
• A read-only SDK lets other tools embed frames/exports without duplicating development.

Concrete, verifiable outputs for every ada

• Public webapp, repository, docs, SDK, adapters (Kupo/Ogmios), exports (Mermaid/DOT/PNG/SVG), and a timeline report generator.
• Benchmarks, test corpora, and golden files prove correctness and performance.
• Monthly releases, status page, and a final Close-out Report & Video provide auditable proof of delivery.

Operating cost discipline (12 months included)

• Hosting reserve covers one year after v1.0 (S3/CloudFront, Fargate, RDS, SQS, CloudWatch), sized for steady community use and able to scale down during quiet periods.
• AWS Budgets/alerts, tagged resources, and autoscaling minimize waste; monthly cost summaries included in public updates.

Unit-value framing

• If the hosted app serves ≥300 distinct targets in year 1, the hosting reserve (~12,000 ₳) implies ~40 ₳/target to deliver timeline debugging and exports at zero cost to the user.
• Exports and SDK calls compound value: once indexed, cached frames keep per-use cost extremely low.

Risk-adjusted design

• Server-side precompute + snapshot caching reduce runtime costs and keep the UI snappy without over-provisioning.
• Adapter modularity avoids third-party API lock-in and lets us add a self-hosted node only if usage justifies it.
• Clear roll-back/roll-forward paths and reorg windows limit rework risk.

Accountability & transparency

• Milestone-tied spend with a public ledger.csv that reconciles allocations to actuals.
• Public status page (uptime/latency), benchmark reports, and release notes link to measurable KPIs (adoption, on-chain-derived counts, performance, export success).
• Close-out deliverables ensure the community can verify outcomes independently.

Long-term value

• After the free year, the tool remains fully self-hostable; we will seek additional resources/partners to extend hosting without requiring new treasury funds.
• Standardized, reusable graphs and reports raise documentation quality across many projects, reducing future debugging costs ecosystem-wide.

Every ada here purchases open, inspectable software that immediately improves Cardano developer productivity, ships with a full year of free access, and remains useful indefinitely through self-hosting. With lean ops, transparent accounting, and measurable KPIs, this proposal delivers clear, compounding value to the community at a prudent, well-justified cost.

[Required Acknowledgements] Consent & Confirmation

Terms and Conditions:

Yes