Divine Life

Divine Life was an experiment in reimagining how people consume horoscope content.

Most astrology applications feel like dashboards.

I wanted to explore what would happen if astrology felt more like an emotionally guided experience.

You can explore the source code here.

The Problem

Most horoscope applications expose raw API responses directly to users.

Large text blocks.

Static cards.

Disconnected widgets.

While functional, these experiences often feel transactional rather than meaningful.

I wanted to design something that felt emotionally responsive instead of mechanically reactive.

Product Vision

The product was intentionally designed as a single-screen experience.

Rather than navigating between pages, users interact with one continuously evolving interface.

Changing a horoscope category updates:

• Visualizations
• Predictions
• Insights
• Emotional framing
• Supporting guidance

Everything responds together.

This creates a feeling of continuity rather than fragmentation.

Core Product Principles

Three principles guided the design:

Emotional Continuity

Interactions should feel connected rather than isolated.

Progressive Discovery

Users uncover information through exploration rather than reading large content blocks.

Synchronized Systems

Every interaction should influence the surrounding experience.

These principles shaped both the product experience and technical architecture.

Technical Architecture

The platform was built using:

• Next.js
• TypeScript
• Tailwind CSS
• Framer Motion
• Recharts

The architecture follows a secure proxy pattern:

Frontend
    ↓
Internal API Route
    ↓
External Horoscope API
    ↓
Response Normalization
    ↓
Reactive UI Components

This prevents API credentials from being exposed while maintaining a clean separation between providers and presentation layers.

Security Considerations

One of the key engineering decisions was ensuring that external API credentials never reached the client.

All requests flowed through internal API routes where:

• Inputs were validated
• Credentials were injected server-side
• Responses were normalized

This approach made the application production-ready while keeping infrastructure simple.

What I Learned

Divine Life reinforced an important lesson.

Products are not just collections of features.

They are collections of feelings.

Two products may expose identical information, yet create completely different user experiences depending on how that information is structured, revealed and presented.

Why Development Stopped

The product was built on top of a third-party horoscope API that provided a limited trial period.

Once the trial expired, continued development required a paid subscription.

Rather than extending the subscription, I treated Divine Life as a product design and engineering experiment focused on interaction design, architecture and emotional UX.

Even though development paused, many of the product concepts continue to influence how I think about user experiences today.