I’m Dan — a software developer who enjoys turning messy ideas into tidy systems, preferably with strong types, sensible architecture, and tests that catch mistakes before they become “interesting incidents”.

I’m interested in how systems behave as they grow: where boundaries hold, where they leak, and how to keep things understandable instead of clever.

• Languages: C#, JavaScript, SQL, Python

• Frameworks: .NET / ASP.NET Core, Node.js / Express

• Data: Entity Framework Core, Prisma, SQLite, Azure SQL, Postgres

• Cloud & Infra: Azure, AWS (IoT), CI pipelines, environment-based config

• Practices: Clean architecture, role-based access, migrations, testing, observability

Tools are chosen to be boring, reliable, and defensible.

Each of these projects explores the same core engineering principles — clear domain boundaries, explicit behaviour, and systems that remain understandable as they grow — applied at different scales and in different contexts.

A modular calculator engine focused on deterministic logic, explicit rules, and extensibility in a deliberately small problem space. Used to explore clean separation between parsing, execution, and presentation, and to treat “simple” logic with the same discipline as larger systems.

→ https://github.com/danross2683/AnyCalc

A practice-ready Node.js / Express backend with a lightweight dashboard, modelling real-world concerns such as JWT authentication, role-based access, projects, invitations, filtering, exports, admin observability, and background jobs.

TaskFlow applies the same clarity and boundary discipline as AnyCalc, but in a multi-user, stateful system.

→ https://github.com/danross2683/TaskFlow (or your actual repo link)

A production-structured ASP.NET Core MVC application built with C#, Entity Framework Core, and SQL, modelling a real service marketplace with booking lifecycles, task matching, and role-aware workflows.

This project extends the same principles into end-to-end domain modelling, persistence, and deployment on Azure.

→ https://github.com/danross2683/RentADad-New

A local-first emulator library manager built with Node.js and JavaScript, integrating Libretro to support multiple emulator cores through a unified orchestration layer.

Romulus focuses on process isolation, execution boundaries, explicit configuration, and long-term maintainability when coordinating complex external systems.

→ https://github.com/danross2683/Romulus

An experimental IoT + cloud system combining Python, Raspberry Pi, and AWS IoT, exploring device communication, state synchronisation, and reliability when software interacts with the physical world.

PillBoi deliberately sits outside the main narrative as a reminder that real systems break in different ways once hardware is involved.

→ https://github.com/danross2683/pillboi

Modern JavaScript / Node.js patterns and tooling

Cloud-native thinking: deployments that are repeatable, observable, and boring

Better testing strategies and API design

When to stop polishing and ship

C#, .NET, SQL, system design, backend architecture, DevOps fundamentals, networking concepts, or why “it works on my machine” is not a QA strategy.

GitHub issues or discussions here, or LinkedIn (linked on my profile).

I’ve built software across web, cloud, mobile, and IoT, I enjoy architecture diagrams far too much, and I use long-distance running as a form of background garbage collection for my brain.

I’m interested less in frameworks and more in how systems behave over time.

Across my projects, I consistently prioritise:

• Clear domain boundaries over convenience

• Explicit behaviour over hidden magic

• Correctness first, then performance and polish

• Separation of orchestration and execution

• Extensibility without conditional sprawl

• I prefer systems that are boring in production, easy to reason about, and resilient to change. If a design decision can’t be explained simply, it probably isn’t finished yet.

Each project here explores the same principles at a different scale — from small, deterministic logic engines to multi-user backends and system-level orchestration.