-
Notifications
You must be signed in to change notification settings - Fork 0
Home
Reminders is a deliberately simple product with a deliberately ambitious implementation: one reminder CRUD domain, built and rebuilt across nearly a decade of stacks. What started in 2017 as an ASP.NET MVC monolith is now a polyglot platform with three interchangeable API implementations, two web frontends, a mobile app in progress, a smart contract, and a documented engineering process run with AI agents as contributors.
It exists to learn in public and to have something worth showing: every era below left behind working code, and most of it still runs today with docker compose --profile all up -d.
| Era | Years | Releases | Headline |
|---|---|---|---|
| Origins | 2017 | v1.0.0 | ASP.NET MVC monolith on SQL Server |
| Layers and tests | 2018-2019 | v2.0.0 | Service layer, first tests, .NET Core |
| Containers | 2020 | v2.0.1, v3.0.0 | Docker, compose, k6 stress tests |
| Modernization | 2021-2022 | v5.0.0 | .NET 5/6, repo restructure, Conventional Commits |
| Frontend era | 2023-2024 | Next.js React app, full test coverage | |
| Web3 and AI assistance | 2025 | Solidity contract, Cypress E2E, first agent PRs | |
| Polyglot and agentic | 2026 | v5.0.1 | Go and C++ APIs, Flutter, ADRs, sprint board |
771 commits from 2017-01-12 to today. The busiest years tell the story: 219 commits in 2020 (the Docker push) and 120 already in 2026 (the agentic era).
The first commit, "First commit Reminders - Add project", landed on 2017-01-12: an ASP.NET MVC application with SQL Server, jQuery, and Bootstrap. The early months were classic first-project energy: create/update/delete/list, page validation, grid sorting, pt-BR culture configuration, and learning git the hard way (deleting .suo files and project.lock.json from history).
- ASP.NET MVC monolith with SQL Server persistence
- A Web API project and an AngularJS client appeared as an experiment the same year
- v1.0.0 tagged in November 2017
The monolith grew structure. A service layer and unit of work pattern separated concerns, and testing entered the project for the first time.
- Unit of work and service layer refactor (2018), v2.0.0 in April 2018
- First unit tests, then API tests with exception handling moved out of controllers
- Swagger added to the API
- Upgraded to C# 8 and .NET Core 3.1 (2019)
The busiest year until 2026: 219 commits, almost all infrastructure. The application became something you run with one command instead of a Visual Studio solution you configure by hand.
- Docker and docker-compose definitions for API, MVC, and database
- k6 stress testing introduced
- Publish pipelines and VS Code tasks
- v2.0.1 and v3.0.0 tagged in May 2020
Fewer commits, bigger housekeeping. The repository took its modern shape and its modern conventions.
- Migrated to .NET 5, then .NET 6
- Repo restructured into the
src/layout still used today (apps, servers, tests in dedicated folders) - Conventional Commits adopted (
feat:,chore:,ci:appear in history from 2021 on) - SQLite support and docker compose profiles
- v5.0.0 tagged in September 2021; v4 was skipped, a version number lost to enthusiasm
The project stopped being backend-only. A modern React frontend arrived and was driven to full test coverage.
- Nginx and stress-test infrastructure (December 2023)
- Next.js React app first committed January 2024
- React Query, context providers, and a test-coverage push across hooks and components
- Dependabot arrived, beginning the long war against npm advisories
Two firsts: the project gained a blockchain service, and AI agents started opening pull requests.
- Solidity smart contract with Hardhat tooling (June 2025), integrated with the .NET API via a local Ganache node
- Cypress end-to-end tests (June 2025)
- GitHub Copilot agent PRs appear in history (
copilot/fix-*branches) - React app deployed to GitHub Pages as a static export
- Security hardening, including XSS fixes in the MVC views
The current era, and the most deliberate one. The same REST contract was reimplemented in two more languages, a mobile client started, and, just as importantly, the process itself became an artifact: ADRs, PRDs, a sprint board, and a documented workflow for AI agents as day-to-day contributors.
- Go API (January, PR #148) and C++ API (March), joining .NET behind the Nginx load balancer
- Flutter app scaffolded (July, PR #384)
- ADR system and agent workflow guide (July, PR #313); seven ADRs to date
- Product vision and PRD workflow, Project 7 board with two-week sprints
- Multi-agent contribution workflow formalized (ADR-0007, August 2026)
- Design tokens landed in React and MVC, groundwork for the v6.0.0 redesign
- v5.0.1 tagged in July 2026, the first release in five years
One REST contract, three interchangeable API implementations behind an Nginx load balancer, two frontends, and a dedicated migrations runner that prepares the database before any API starts.
flowchart LR
subgraph Clients
react[React app :3000]
mvc[MVC app :5050]
flutter[Flutter app]
end
nginx[Nginx load balancer :9999]
subgraph "API implementations"
dotnet[.NET API :5000]
goapi[Go API :5001]
cpp[C++ API :5002]
end
migrations[Migrations runner]
pg[(PostgreSQL :5432)]
ganache[Ganache node :8545]
react --> nginx
mvc --> nginx
flutter -.-> nginx
nginx --> dotnet
nginx --> goapi
nginx --> cpp
dotnet --> pg
goapi --> pg
cpp --> pg
dotnet --> ganache
migrations --> pg
Details worth knowing:
- Nginx round-robins across the three APIs; an
X-Serverresponse header tells you which implementation answered (dotnet,go, orcpp). - .NET is the reference implementation and the only one with blockchain integration.
- Startup order is enforced: PostgreSQL healthy, then the migrations runner completes, then the APIs start.
- PostgreSQL is the default provider; SQL Server is supported with its own migration set, and every schema change ships migrations for both.
- The Flutter app (dashed) is in progress and consumes the same REST contract.
Since mid-2026 the process is as much a portfolio piece as the code:
-
Trunk-based development: short-lived branches off
main, squash merges, Conventional Commit titles enforced by CI (ADR-0001) - One board: GitHub Project 7 with Backlog/Todo/In Progress/Done, priorities, initiatives, and two-week sprints (ADR-0002)
- Decisions as records: seven ADRs cover the workflow, the board, the multi-implementation API, dual-database migrations, blockchain integration, the PRD flow, and the agent contribution loop (ADR index)
- Product intent: a vision doc and one-page PRDs for feature-sized work (ADR-0006)
- Agents as contributors: AI agents claim issues, work in worktrees, and open PRs under the same quality gates as humans (ADR-0007)
The release roadmap:
| Release | Theme |
|---|---|
| v5.1.0 | Audit hardening |
| v6.0.0 | Redesign |
| v6.1.0 | Observability and release automation |
| v6.2.0 | Demo and AI integrations |
| v6.3.0 | Agentic workflow automation |
| v7.0.0 | Polyglot APIs and experiments |
| v8.0.0 | Cloud deployment |
The product vision points at four pillars: reliable delivery (scheduled notifications with retries and idempotency), assistive intelligence (natural language capture and semantic search), an event-driven core (domain events consumed by the Go and C++ services), and open explorations (auth, rate limiting, health checks). The rule that keeps it honest: if a feature cannot be expressed in the shared REST contract, it is not ready.