Build a Personal Project Dashboard with Angular and .NET
Personal software often begins as a promising folder: experiments, abandoned prototypes, notes and repositories all mixed together. A project dashboard turns that pile into a useful operating view. It can show active builds, blocked tasks, recent commits, maintenance chores and learning goals without asking you to remember every detail. The result should help you choose what to do next, not merely display how busy you have been.
Building a personal project dashboard with Angular and .NET gives a solo developer a practical command centre. Angular can provide a responsive interface, typed services and clear component boundaries, while C# handles domain rules, background jobs and integrations with services such as GitHub. SQL Server gives the project history a durable home, and the same stack can move from a laptop to a small production service without a rewrite.
This approach suits Australian developers balancing employment, client work and side projects around Sydney, Melbourne, Brisbane or Perth. It also reflects the practical constraints of a crowded market for solo developers and small consultancies: keep operating costs predictable, make maintenance manageable and avoid building enterprise machinery for a one-person product. The perspective behind the site appears in Steven McLintock’s background, where technical growth and a changing career meet.
Shape the dashboard around daily decisions
Begin with a list of questions the dashboard must answer. Which projects need attention today? Which have gone quiet? What is waiting on a dependency, review or deployment? A learning item may belong beside a repository, but only if it helps decide what happens next. Writing these questions in plain language keeps the model honest and gives every card, chart and table a reason to exist.
Turn the answers into small vertical features. A useful first screen might combine four status counts, an activity feed, an “up next” list and a short weekly summary. Each card should link to the underlying record or action instead of ending at a dead-end statistic. External data, such as GitHub issues or pull requests, can be introduced later once the local workflow feels complete on its own.
Keep the first release personal rather than pretending it is a team product. One person, one authentication flow and a handful of well-defined records are easier to test and cheaper to run than a plug-in framework. This matters in Australia’s freelance and consultancy market, where a side tool must earn its spare time and hosting bill. A narrow tool that survives a busy week is more valuable than a grand platform that needs constant attention.
Model the project domain in C#
The backend can start with a compact C# domain: Project, Milestone, Activity and LearningGoal. Give each entity a stable identifier, timestamps, status and the relationships needed by the dashboard. Keep repository metadata and issue references in their own records rather than stuffing them into a JSON blob. That small amount of structure makes filtering, reporting and later migrations much less painful.
Model states as constrained values rather than free-form strings. “Active”, “paused”, “blocked” and “complete” each need rules: a paused project might hide active milestones, while a blocked milestone should expose its reason and owner. These rules belong in the API or domain layer so an imported GitHub label cannot silently create a state the interface cannot handle. An enum or validated value object works well here.
Expose purposeful endpoints such as project summaries, recent activity, milestones and dashboard aggregates. Return DTOs designed for the screen, not full database entities with navigation properties in every response. Include pagination for activity, UTC timestamps and stable sorting keys. An OpenAPI document generated from the ASP.NET Core project also gives the Angular team a contract that can be checked in CI instead of relying on memory.
Connect Angular to a dependable API
On the Angular side, create a typed API client around HttpClient and keep endpoint URLs in environment configuration. Standalone components and signals make it straightforward to share dashboard state without a global event bus. A service can expose computed values such as activeProjectCount or overdueMilestones, while each presentational component receives only the data it needs. The frontend should render the API contract, not duplicate the business rules used to calculate it.
Handle loading, empty and failure states as normal parts of the interface. A dashboard with no projects is different from one whose request failed, and a stale summary should say so. Use retry with backoff for transient calls, cancel obsolete requests when filters change and display the last successful update time. Log correlation identifiers from the response so a problem seen in the browser can be traced to a server request.
Live updates do not need a complex real-time platform. Polling every minute or refreshing after a mutation is often enough for a personal tool. If you prefer a push channel, SignalR can carry a small “project changed” event, after which Angular reloads the affected query. Whichever route you choose, make updates idempotent and ensure a missed WebSocket message cannot leave the interface permanently out of sync.
Design a focused interface for everyday use
Design the main screen for a quick morning review. Put the few decisions that need attention at the top, with project status and recent activity below. Use restrained colour, clear labels and compact charts; a pie chart for every category quickly becomes noise. On mobile, replace dense tables with stacked project cards and offer filters that work with one thumb. Accessibility still matters: keyboard focus, contrast and semantic headings cost little to include from the start.
Format dates and times for an Australian audience. Display day-first dates, label the time zone and store instants in UTC so daylight-saving changes do not corrupt activity ordering. A developer in Perth may open the dashboard while a teammate in Sydney is still heading into the afternoon, making the three-hour difference worth showing explicitly. A quick “updated arvo” label can feel friendly, though the exact time should remain available for anyone coordinating a deployment.
Use familiar language without turning the product into a caricature. Australian teams often sound relaxed—“no worries” can soften a handoff, but operational alerts still need precise wording. Say which project failed, when it failed and whether retrying is safe. Tooltips, empty states and error messages should use the same status names as the API, removing the small mental translation that otherwise appears between backend terminology, GitHub labels and the dashboard.
Protect data across SQL Server and Angular
SQL Server works well for the relational core, and Entity Framework Core can manage schema changes through migrations. Keep the API as the only component allowed to write to the database. Store GitHub credentials, connection strings and other secrets in environment variables or a managed secret store, never in Angular bundles. Browser code should call your endpoints; it should never hold a personal access token that can grant access to private repositories.
Choose authentication based on who will use the dashboard. ASP.NET Core Identity can support a small multi-user setup, while an OpenID Connect provider such as GitHub or Microsoft Entra ID may be simpler for a single account. Use secure, HTTP-only cookies, CSRF protection for state-changing requests and server-side authorisation checks for every project record. Hiding a button in the interface is not access control.
Protect the operational side as well. Schedule regular database backups and test that a restore works, then apply sensible retention rules to raw integration logs. Index fields you actually filter by, such as project status and activity time, and monitor query duration as the history grows. A personal service can be small without being careless; predictable usage, patching and recovery are cheaper than an outage followed by a rushed rebuild.
A practical release checklist
Deploy the Angular build as static assets and host the API and database as separate managed services. An Azure App Service paired with Azure SQL Database and the Australia East region can keep latency low for users in Australia. Compare the total monthly cost before selecting tiers, because AUD billing, backup storage and idle background jobs add up. A modest single-instance configuration is enough until real usage proves more capacity is needed.
Put the database migrations into a controlled release step and keep the previous application version available for rollback. Add structured logs, request timing and an error tracker such as Application Insights or Sentry. For a tool used mainly by its owner, a weekly health summary can be more valuable than a flood of alerts: uptime, failed synchronisation runs, storage growth and the projects that received no activity.
- Ship one complete workflow first: projects, milestones and a dependable activity feed.
- Keep third-party synchronisation incremental and idempotent, storing the last successful cursor so a retry cannot duplicate records.
- Test domain rules in the .NET project and critical component states in Angular before every release.
- Make deployments observable with health checks, structured errors and a tested rollback path.
- Review the dashboard after a normal working week and remove features that never influence a decision.
Treat the checklist as a learning loop rather than a one-off launch gate. If the activity feed never changes the next action, remove it; if a sync repeatedly fails, fix or disable it before adding another source. This keeps a modest system aligned with the work it is meant to support.
Keep the dashboard useful beyond launch
Once the dashboard is live, let it evolve with your work. The most valuable records may shift from repositories to learning goals, client constraints or maintenance windows. Keep the domain deliberately small, but let categories and views be configured rather than hard-coded. A good personal system reflects how you actually plan, while remaining simple enough to update on a Friday afternoon when motivation is low.
Protect the habit by keeping updates close to existing actions. Let the GitHub integration update repository activity automatically, but record decisions and next steps manually where judgement matters. Review the dashboard during your normal Friday wrap-up and remove anything that has not influenced a decision. If you skip it for several weeks, the tool has probably become another chore rather than an aid.
Choose one active project, one meaningful update and one source of historical data, then build that vertical slice before expanding the scope. Publish it for your own use and measure it by one result: how much faster you move from an idea to the next completed piece of work. That is the standard the dashboard must meet.