HimLedger is a full-stack corporate expense management platform designed to bring structure, accountability, and visibility to the employee reimbursement lifecycle.
Instead of relying on disconnected spreadsheets, email chains, manual approvals, and scattered financial records, HimLedger provides a centralized workflow for managing expenses from submission through approval and audit.
The platform separates responsibilities across employees, managers, finance teams, and administrators while maintaining a clear operational record of activity.
Employee
│
│ Submit expense claim
▼
HimLedger
│
│ Validation & workflow
▼
Manager
│
│ Review / Approve / Reject
▼
Finance
│
│ Financial oversight
▼
Reimbursement
│
▼
Audit History
The result is a more structured approach to expense operations where every claim has a place, every role has a responsibility, and important activity can be traced.
Expense management becomes difficult when the process grows faster than the tools supporting it.
Employees need a simple way to submit claims.
Managers need a consistent approval process.
Finance teams need visibility into spending.
Administrators need control over users, roles, budgets, and operational activity.
HimLedger brings these responsibilities together into one application.
| Principle | Purpose |
|---|---|
| Clarity | Make expense activity easy to understand |
| Control | Enforce structured approval and access workflows |
| Accountability | Maintain visibility into important actions |
| Security | Protect financial and operational data |
| Scalability | Provide an architecture suitable for cloud deployment |
Employees can submit and track expense claims through a centralized workspace.
- Create expense claims
- Track claim status
- Attach supporting documentation
- Review historical submissions
- Monitor claim progress
HimLedger provides structured workflows for managerial review.
Managers can:
- Review submitted claims
- Inspect supporting information
- Approve claims
- Reject claims
- Monitor outstanding work
This replaces informal approval processes with a defined operational workflow.
Financial teams can monitor organizational spending through centralized budget and department-level information.
The platform is designed to provide visibility into:
- Department spending
- Budget utilization
- Expense activity
- Claim volumes
- Financial operations
Different users require different levels of access.
HimLedger separates responsibilities through role-based authorization.
┌─────────────┐
│ Employee │
└──────┬──────┘
│
│ Submit & track
▼
┌─────────────┐
│ Manager │
└──────┬──────┘
│
│ Review & approve
▼
┌─────────────┐
│ Finance │
└──────┬──────┘
│
│ Financial oversight
▼
┌─────────────┐
│ Admin │
└─────────────┘
This keeps functionality aligned with organizational responsibilities.
Expense claims can contain supporting documents and receipts, allowing financial information to remain associated with the relevant claim.
This provides a more complete record for review and auditing.
HimLedger is designed around operational transparency.
Important activity can be surfaced through an audit workspace, giving administrators and authorized users a clearer picture of what happened within the system.
Instead of asking:
"Who changed that?"
the goal is for the system to already have the answer.
HimLedger follows a layered full-stack architecture separating the presentation layer, API, business logic, domain model, infrastructure, and cloud resources.
┌─────────────────────┐
│ Browser │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ React + TypeScript │
│ + Vite │
└──────────┬──────────┘
│
HTTP / API
│
▼
┌─────────────────────┐
│ ASP.NET Core │
│ API │
└──────────┬──────────┘
│
┌───────────────┼───────────────┐
│ │ │
▼ ▼ ▼
┌────────────┐ ┌────────────┐ ┌──────────────┐
│ Application│ │ Domain │ │Infrastructure│
│ Layer │ │ Layer │ │ Layer │
└────────────┘ └────────────┘ └───────┬──────┘
│
▼
┌──────────────┐
│ SQL Server │
└──────────────┘
│
▼
┌──────────────┐
│ Azure │
│ Infrastructure│
└──────────────┘
The HTTP-facing ASP.NET Core application.
Responsible for:
- API endpoints
- HTTP configuration
- Authentication and authorization integration
- Dependency injection
- Application startup
Contains application-level business workflows and use cases.
This layer coordinates operations between the API, domain model, and infrastructure.
Contains the core domain model and business concepts.
The domain layer is kept independent from infrastructure concerns wherever possible.
Responsible for external persistence and infrastructure concerns.
This includes:
- Entity Framework Core
- SQL Server integration
- Database configuration
- Persistence
- Infrastructure services
Unit tests focused on domain-level behaviour.
Integration coverage for API-level behaviour and interactions between application components.
| Technology | Purpose |
|---|---|
| React 19 | User interface |
| TypeScript | Type-safe application development |
| Vite | Frontend development and build tooling |
| Tailwind CSS | UI styling |
| Vitest | Unit testing |
| Playwright | End-to-end testing |
| Technology | Purpose |
|---|---|
| .NET 8 | Application platform |
| ASP.NET Core | REST API |
| Entity Framework Core | Data access and ORM |
| C# | Backend development |
| xUnit / test stack | Automated testing |
| Technology | Purpose |
|---|---|
| SQL Server | Relational data storage |
| Entity Framework Core | Database abstraction |
| SQL Schema | Database structure and deployment support |
| Technology | Purpose |
|---|---|
| Microsoft Azure | Cloud platform |
| Azure App Service | Application hosting |
| Azure Key Vault | Secret management |
| Application Insights | Application monitoring |
| Bicep | Infrastructure as Code |
- Role-based authorization
- Secure configuration management
- Azure Key Vault integration
- Entra ID support
- Separation of application responsibilities
- Controlled access to operational functionality
HimLedger/
│
├── backend/
│ │
│ ├── HimLedger.Api/
│ │ └── ASP.NET Core API
│ │
│ ├── HimLedger.Application/
│ │ └── Application services & workflows
│ │
│ ├── HimLedger.Domain/
│ │ └── Core domain models & business rules
│ │
│ ├── HimLedger.Infrastructure/
│ │ └── EF Core, persistence & infrastructure
│ │
│ ├── HimLedger.Domain.Tests/
│ │ └── Domain unit tests
│ │
│ ├── HimLedger.Api.IntegrationTests/
│ │ └── API integration tests
│ │
│ ├── HimLedger.sln
│ ├── HimLedger.Schema.sql
│ ├── README.md
│ └── OPERATIONS.md
│
├── frontend/
│ │
│ ├── src/
│ ├── public/
│ ├── package.json
│ ├── vite.config.ts
│ ├── vitest.config.ts
│ ├── playwright.config.ts
│ └── README.md
│
├── infra/
│ │
│ ├── main.bicep
│ └── README.md
│
├── docs/
│ └── screenshots/
│
├── .github/
│
├── CONTRIBUTING.md
├── .gitignore
└── README.md
Before running HimLedger locally, make sure you have:
- .NET 8 SDK
- Node.js 22+
- SQL Server
- Git
Verify the installed versions:
dotnet --version
node --version
npm --versiongit clone <your-repository-url>
cd HimLedgerRestore the .NET solution:
dotnet restore backend\HimLedger.slnApply Entity Framework Core migrations:
dotnet ef database update `
--project backend\HimLedger.Infrastructure `
--startup-project backend\HimLedger.ApiStart the API:
dotnet run `
--project backend\HimLedger.Api `
--launch-profile httpOpen another terminal:
cd frontend
npm ci
npm run devThe frontend will be available at:
http://localhost:5173/login
HimLedger includes seeded development accounts for testing different authorization roles.
| Role | |
|---|---|
| Administrator | admin@himledger.test |
| Manager | manager@himledger.test |
| Employee | employee@himledger.test |
| Finance | finance@himledger.test |
Development password:
test1234
⚠️ These credentials are intended for local development and testing only. Do not use them in production.
HimLedger uses automated validation across the backend and frontend.
dotnet build backend\HimLedger.sln --configuration Releasedotnet test backend\HimLedger.sln --configuration Releasecd frontend
npm run lintnpm run test:unitnpm run buildA typical validation workflow is therefore:
┌──────────────┐
│ Source Code │
└───────┬──────┘
│
┌───────▼──────┐
│ Build │
└───────┬──────┘
│
┌─────────┴─────────┐
▼ ▼
┌───────────────┐ ┌───────────────┐
│ Backend Tests │ │ Frontend Tests│
└───────┬───────┘ └───────┬───────┘
│ │
└─────────┬─────────┘
▼
┌──────────────┐
│ Validation │
│ Complete │
└──────────────┘
HimLedger is designed as an operational application rather than simply an API with a frontend attached.
The public-facing landing experience introduces the platform and its purpose.
The administrative workspace provides centralized visibility over operational activity.
The audit workspace provides a dedicated view for tracking operational activity and maintaining accountability.
Employees can manage their expense claims through a dedicated workspace.
HimLedger is structured with cloud deployment in mind.
The infra/ directory contains Azure infrastructure definitions using Bicep.
infra/
├── main.bicep
└── README.md
The intended cloud architecture supports services such as:
Azure
│
┌─────────────┼─────────────┐
│ │ │
▼ ▼ ▼
App Service Key Vault Application
Insights
│
▼
HimLedger API
│
▼
SQL Database
This separation allows application infrastructure and application code to evolve independently.
HimLedger is structured around several engineering principles.
Frontend, API, application logic, domain logic, and infrastructure are separated into distinct areas.
The backend follows a layered structure intended to keep business logic from becoming tightly coupled to infrastructure.
Domain and API behaviour can be tested independently through unit and integration test projects.
Authorization, secret management, role separation, and infrastructure boundaries are treated as application concerns rather than afterthoughts.
Infrastructure is represented as code, making the deployment environment reproducible and easier to maintain.
Additional project documentation is available throughout the repository.
| Document | Description |
|---|---|
backend/README.md |
Backend-specific documentation |
backend/OPERATIONS.md |
Backend operational guidance |
frontend/README.md |
Frontend development documentation |
infra/README.md |
Infrastructure documentation |
CONTRIBUTING.md |
Contribution and development guidelines |
HimLedger is an actively maintained full-stack application with a focus on:
- Expense management
- Claims processing
- Approval workflows
- Budget visibility
- Role-based access
- Auditability
- Automated testing
- Azure deployment
The architecture is intentionally structured so additional operational capabilities can be introduced without turning the codebase into one giant Controllers folder and a prayer.
Potential future development areas include:
- Advanced financial reporting
- Expanded dashboard analytics
- Additional approval workflow configuration
- Enhanced notification workflows
- More comprehensive audit reporting
- Expanded Azure deployment automation
- Additional end-to-end test coverage
- Advanced budget forecasting
- Richer administrative controls
Roadmap items represent potential future development and are not necessarily implemented in the current release.
Contributions, improvements, and technical feedback are welcome.
Before opening a pull request:
- Review
CONTRIBUTING.md - Build the backend successfully
- Run backend tests
- Run frontend linting
- Run frontend unit tests
- Confirm the production frontend build succeeds
- Keep changes focused and documented
For larger architectural changes, document the reasoning behind the change rather than simply documenting what changed.
Future-you will appreciate it.
This project is currently maintained for internal operational use.
The repository does not currently define a permissive open-source license. Please confirm repository ownership and licensing terms before redistributing, modifying, or commercially using the project.
HimLedger brings together:
React
+
TypeScript
+
Vite
+
Tailwind CSS
│
▼
ASP.NET Core
+
.NET 8
+
Entity Framework Core
│
▼
SQL Server
│
▼
Azure
The result is a full-stack platform designed to demonstrate how a modern business application can combine frontend engineering, backend architecture, relational data, authorization, testing, auditing, and cloud infrastructure into a single system.
HimLedger
Make the money trail make sense.
Built with ☕, C#, TypeScript, and an unreasonable number of database queries.
```