Digital health platform In progress

Glicare

A full-stack health application that turns glucose records into clear trends and structured information for patients and care conversations.

Glicare product presentation

The project

Project overview

Context

Diabetes management depends on frequent records, but the information is often scattered across paper notes, devices and isolated appointments.

Problem

Patients needed a simpler way to understand glucose trends while care teams needed consistent, structured information to support better conversations.

Solution

Glicare brings measurements, medication routines and progress indicators into one responsive experience designed around quick daily use.

Role
Full-stack development and product design
Type
Responsive web application
Status
In progress
Timeline
1 month
Year
2026

Product experience

Key features

Purposeful capabilities shaped around the core user journey.

  • Frictionless glucose logging

    Fast, validated records with contextual notes for meals, symptoms and medication.

  • Readable health trends

    Daily and weekly views reveal patterns without overwhelming the user with clinical data.

  • Medication routine

    A clear schedule connects treatment activity to the wider health timeline.

  • Care-ready summaries

    Structured history makes appointments more focused and supports informed decisions.

  • Responsive by default

    The same core workflow remains quick and legible across phones, tablets and desktops.

  • Accessible interaction

    Semantic structure, keyboard support and strong contrast serve a broader range of users.

Under the hood

Tech stack

Tools selected for the role they play in a maintainable, end-to-end system.

Front-end

  • Angular

    Component architecture, routing and reactive UI state.

  • TypeScript

    Strict domain contracts and safer application logic.

Back-end

  • Spring

    REST services, validation and application security.

  • Java

    Typed domain logic and dependable server-side workflows.

Database

  • PostgreSQL

    Relational storage for health records and user data.

Infrastructure

  • Docker

    Consistent local and deployment environments.

  • AWS

    Managed hosting and durable cloud resources.

Testing

  • JUnit

    Unit and integration coverage for critical rules.

System design

System architecture

A layered web architecture keeps the interface, application rules and persistence independently maintainable. The Angular client communicates with a secured REST API, which coordinates domain services and PostgreSQL.

Main system components and their communication flow

  1. Angular client

    Responsive UI and local interaction state

  2. REST API

    Authentication, validation and orchestration

  3. Domain services

    Health rules and use-case logic

  4. PostgreSQL

    Structured and durable health records

Core journey

How it works

  1. Record

    The patient adds a glucose measurement and relevant context.

  2. Validate

    The API checks the input and applies the health domain rules.

  3. Organise

    The record becomes part of the secure longitudinal timeline.

  4. Understand

    Updated summaries surface patterns and support the next action.

Behind the product

Engineering

The technical choices and trade-offs that shaped a reliable product experience.

Trade-offs

Technical decisions

  1. Layered application boundaries

    Separate presentation, application rules and persistence.

    Clear boundaries keep health rules testable and allow the interface to evolve without leaking infrastructure concerns.

  2. Relational data model

    Use PostgreSQL for clinical and account records.

    Strong consistency, explicit relationships and transactional operations fit the domain better than flexible document storage.

  3. Progressive disclosure

    Lead with the next useful action and reveal deeper detail on demand.

    Health data can feel dense; a calmer hierarchy reduces cognitive load during frequent, short sessions.

Problem solving

Engineering challenges

Making dense data feel clear

Challenge
Measurements gain meaning through time, meals and medication, creating a high information density.
Solution
Group the experience around daily decisions, with progressive detail and consistent visual signals.
Result
A faster scan path that keeps trends understandable without hiding important context.

Protecting critical records

Challenge
Health information requires reliable writes, strict ownership and predictable validation.
Solution
Validate at API boundaries, enforce authorisation server-side and wrap related writes in transactions.
Result
A dependable data flow with failures handled before incomplete state reaches the timeline.

Quality attributes

Built beyond the happy path

Security

Defence in depth protects identity and sensitive health records.

  • Server-side authorisation
  • Validated API boundaries
  • Least-privilege access

Performance

Small payloads and focused rendering keep daily interactions responsive.

  • Route-level loading
  • Indexed timeline queries
  • Stable responsive media

Testing

Risk-based coverage focuses on domain rules and essential user journeys.

  • Domain unit tests
  • API integration tests
  • Critical-flow UI tests

Observability

Structured signals make failures easier to diagnose without exposing private data.

  • Structured application logs
  • Health checks
  • Error-rate monitoring

Reflection

Lessons & next steps

Key learnings

  • Designing around user decisions creates a clearer product than mirroring the database model.
  • Explicit domain boundaries reduce rework when interface requirements change.
  • Accessibility decisions are most effective when included in the component structure from the start.

Next steps

  • Add device integrations for automatic glucose synchronisation.
  • Introduce configurable reports for care teams.
  • Expand trend insights while keeping clinical interpretation transparent.