AstroSense

astrosense.ai⁠ (opens in a new tab) is a birth-chart astrology product built on a simple, slightly contrarian idea: astrology software should be deterministic. The same birth data, run through the same engine, always produces exactly the same chart and the same reading. No randomness, no vague generator, no drift between one visit and the next.

That constraint turned into the whole architecture. Because the chart math is deterministic and computed locally, I could build a content system on top of it where the expensive part, the writing, is grounded in reproducible facts and generated once, then served read-only forever. That is what lets a solo project publish a fresh horoscope for all twelve signs every day, a growing library of celebrity birth-chart reports, and daily Instagram and Facebook carousels, without a per-request AI bill.

The interesting part of this project is not the astrology. It is the machine I built to produce and distribute the content.

Solo: product, design, engineering, and the content and growth systems.

The thesis

Most astrology apps are one of two things: a thin wrapper over a paid ephemeris API, or a content mill that pipes prompts straight into an LLM and prints whatever comes back. The first is expensive and opaque. The second is cheap and generic, and it reads like it.

I bet on a third path. Compute the chart with real astronomy, locally and deterministically. Ground every piece of written content in that exact computed chart. Then treat writing as the scarce resource it actually is, and design the system so I only pay for it once.

The product promise on the site is one line: patterns, not predictions, and the same sky always reads the same way. That is not marketing. It is a description of the engine.

Product and design

The product is a funnel with a lot of genuinely free surface area around a single paid object.

The paid object is the Snapshot Report: a full birth-chart reading, seventeen sections covering identity, mind, love, work, money, health, beliefs, shadow, and life direction, each one anchored to specific placements in the chart. It is a one-time purchase, not a subscription. I made that call deliberately. A reading computed from a fixed birth moment does not change, so charging rent for it would be dishonest.

Everything else is free and exists to bring people in:

• A daily horoscope⁠ (opens in a new tab) for all twelve signs, computed from the real sky each morning.
• A cast-your-chart⁠ (opens in a new tab) flow that gives an instant, deterministic teaser the moment someone enters their birth details, with no login, no cost, and no AI call. The teaser is assembled from the computed placements, so it is real and specific, and it sets up the paid report as the deeper version.
• A celebrity chart library⁠ (opens in a new tab), a public and growing set of full birth-chart reports for well-known figures, which doubles as the SEO engine.
• A born-today view, sky events⁠ (opens in a new tab), and a sign compatibility⁠ (opens in a new tab) tool.

Every screen below is the live site at phone width, captured the day this was written. Nothing here is a mockup.

The design language is quiet and typographic, built on a small set of design tokens so the whole surface stays consistent as it grows. The funnel is the design: free tools earn the visit and the trust, the deterministic teaser proves the engine is real, and the paid report is the one place the depth lives.

The record behind it is here, running. The design system, night-sky indigo with one violet accent and one strictly functional sky-blue, Newsreader for headlines, Geist for body and IBM Plex Mono for every piece of chart data: open the design system →. And every screen as designed, from landing to the Snapshot Report, with the three landing directions that were weighed before one was chosen: open the screens →.

The engine

The core is a package I call the engine, and it does one job: turn a birth moment and place into an exact chart.

I built it on astronomy-engine, a pure-computation astronomy library, rather than on Swiss Ephemeris. This was one of the most consequential early decisions. Swiss Ephemeris is the default in this space, but its license is a trap for a commercial product: it is AGPL, which would have forced me to open-source the entire application or pay for a commercial license. astronomy-engine is MIT-licensed and computes positions locally with no external ephemeris files and no API calls. So the chart math has no per-request cost, no third-party dependency at runtime, and no licensing liability. Timezone resolution is handled locally too, from coordinates, with no geocoding service in the loop.

The payoff of computing locally and deterministically is that every downstream system can trust the chart. The same input always yields the same placements, which means a reading can be generated once and cached forever, a teaser can be assembled on the fly without a database round trip, and a celebrity report published today will read identically a year from now. Determinism is not a feature the user sees. It is the property that makes the rest of the system affordable.

The content system, which is the real project

This is the part I am proudest of, because it is where the economics live.

Written content splits into two tiers, and they are paid for in completely different ways.

Paid reports are the only place I spend per-token AI money. When someone buys a Snapshot Report, the system compiles a grounding context from their exact chart, generates the seventeen sections against that context, and runs the result through a validator before it is ever stored. That validator is strict: every section has to hit a minimum depth, every claim has to be anchored to real placements from the grounding, and the house voice rules are enforced in code, including a hard ban on em dashes and a set of anti-generic-writing checks. The report is stamped with the engine version, the ruleset version, and the prompt version, so any reading is fully reproducible and traceable back to the exact inputs that made it. Because purchases are bounded, this cost is bounded.

Free content is authored on a subscription, not an API, so its marginal cost is effectively zero. This is the design move that makes the whole free surface possible. The daily horoscopes and the celebrity reports are written by an LLM running as a scheduled routine on a flat-rate subscription, not billed per token. The routine follows the same shape as the paid path: it fetches a deterministic grounding for each subject (the exact placements, computed by the engine, with no AI involved), authors the prose against that grounding, and posts it through a write-only publish endpoint that re-validates everything before it is stored. The site then serves the stored copy read-only.

The split matters. Grounding is deterministic and free. Validation is deterministic and free. Only the authoring costs anything, and I moved the authoring for all the free content off the metered API and onto a fixed-cost subscription. That is why a solo project can run a daily twelve-sign horoscope and a daily celebrity-report pipeline without the bill scaling with traffic or output.

There is a voice layer sitting across all of it, a shared house style plus a lint pass that scans the copy for banned vocabulary and the usual tells of machine writing. It runs in the test suite, so writing that drifts off-voice fails CI the same way a broken type would.

The automation and growth engine

On top of the content system sits a layer of scheduled automation that runs the publishing and the distribution without me touching it day to day.

Every morning the horoscope routine authors and publishes the day's twelve readings. A separate job then renders those readings into Instagram and Facebook carousel cards and posts them through a self-hosted scheduler, splitting the twelve signs across two posts because Instagram caps a carousel at ten images. The captions lead with the day's real sky and point back to the site, where the full reading lives. The social content is a teaser for the on-site content, which is a teaser for the paid report. It is funnels all the way down, and none of it requires me to write a caption.

The celebrity library is the SEO play. There is a large backlog of seeded public figures, chosen by search demand, and a routine that drains that backlog a few reports a day. Each figure becomes a public, indexable page with a real computed chart and a full report, which is exactly the kind of long-tail content that earns organic search traffic over time. The portraits are sourced from Wikimedia Commons under Creative Commons and public-domain licenses, with per-image attribution rendered on each page, so the whole library is clean from a rights perspective.

The through-line across all of this is a single discipline: know exactly where money is spent. The one audit I keep returning to is the map of what actually costs per-token AI money. The answer is only two things: generating a paid report, and the single teaser call. Everything else, the horoscopes, the celebrity reports, the carousels, the sky events, the compatibility tool, is deterministic computation or subscription-authored, and costs nothing at the margin.

Engineering

The codebase is a pnpm monorepo with a Next.js 15 and React 19 web app and a set of focused packages: the astronomy engine, the content engine that handles grounding and generation and validation, a payments package, a voice package for the house style, shared types, and design tokens. The separation keeps the deterministic compute, the content pipeline, and the UI from bleeding into each other.

The engineering practices are boring on purpose, because boring is what lets one person move fast without breaking the live site:

• A full CI gate on every change: build and type-check, a unit and content-validation suite, security rules tests for the database, an end-to-end Playwright suite that walks the real money path from casting a chart to a stamped report, and a Lighthouse pass for performance and accessibility.
• A local development harness that spins up the Firebase emulators with a demo project and a test mode, so the whole app, including auth, database, and storage, runs locally with zero real keys and zero cost.
• A rule that the end-to-end suite runs locally before anything is pushed, so a green pull request means the money path actually still works.
• Squash-merge into a protected main branch, with the production deploy gated on CI going green.

None of this is novel. All of it is the reason a solo, live, revenue-capable product does not fall over.

A few problems worth mentioning

• The licensing trap. Choosing astronomy-engine over Swiss Ephemeris at the start avoided an AGPL obligation that would have either forced the whole product open-source or added a licensing cost. The boring early decision was the one that kept the project commercially viable.
• Determinism as an economic lever. The reason the free content is affordable is not a clever prompt. It is that the chart math is reproducible, so content can be generated once and served forever, and the expensive step can be isolated and, for free content, moved off the metered API entirely.
• Cost as a first-class design constraint. I treat "what spends money" as an architectural property I can audit, not an accident I discover on a bill. The system is designed so that scaling output, more horoscopes, more celebrity reports, more social posts, does not scale the cost.
• Operability. The automation runs on real infrastructure, which means real failure modes: a scheduler that stalls, a publishing queue that backs up, a permission prompt that hangs an unattended job. Building the content system was half the work. Keeping it running is the other half, and it is where a lot of the actual engineering time goes.

Where it stands

AstroSense is live. It launched as a free funnel, with the full free tool set public and indexable, and the paid report path built and gated behind a final payments go-live that is a configuration change rather than a code change. The chart engine, the two-tier content system, the daily horoscope and social automation, and the celebrity SEO library are all running in production.

The most honest summary of the project is this: the astrology is the surface, and the system underneath is a reusable pattern for any content product. Compute the facts deterministically, ground the writing in them, pay for authoring once, and let automation handle publishing and distribution. AstroSense is where I built that pattern end to end.

Stack: Next.js 15, React 19, TypeScript, a pnpm monorepo, Firebase (Firestore, Auth, Storage), Vercel, astronomy-engine for deterministic chart math, a two-tier LLM authoring pipeline (metered for paid reports, subscription-authored for free content), Playwright and Vitest for testing, and a self-hosted social scheduler for distribution.

See it live at astrosense.ai →⁠ (opens in a new tab)