Tally

Tech Stack

iOS

Web

Backend

Project Snapshot

• Platforms: iOS (iPhone), watchOS, macOS (Catalyst), Web
• Status: Web live on Vercel · iOS under App Store review
• Type: Cross-platform SaaS — real product, not a portfolio demo
• Team: Solo
• Role: Full-stack developer — iOS, web, backend, payments, deployment

Key Features

Technical Decisions

Challenges

Deno.serve(async (req) => {
  const signature = req.headers.get('stripe-signature');
  const body = await req.text();
  const event = await stripe.webhooks.constructEventAsync(body, signature, webhookSecret);

  if (event.type === 'checkout.session.completed') {
    const session = event.data.object;
    const userId = session.metadata.supabase_user_id;
    const plan = session.metadata.plan; // 'pro' or 'business'

    await supabase
      .from('profiles')
      .update({ is_pro: true, plan, plan_updated_at: new Date().toISOString() })
      .eq('id', userId);
  }

  return new Response(JSON.stringify({ received: true }), { status: 200 });
});

func listenForTransactions() -> Task<Void, Error> {
    Task.detached {
        for await result in Transaction.updates {
            guard case .verified(let transaction) = result else { continue }

            if transaction.productID == "com.chstudios.tally.pro" {
                await self.unlockPro(userId: currentUserId)
                await transaction.finish()
            }
        }
    }
}

func unlockPro(userId: String) async {
    try? await supabase
        .from("profiles")
        .update(["is_pro": true, "plan": "pro"])
        .eq("id", userId)
        .execute()
}

What I Learned

• How StoreKit 2 works — non-consumable IAP, transaction verification, and the entitlement listener pattern
• How to wire two completely different payment systems (StoreKit + Stripe) to a single shared database record
• Supabase Edge Functions in Deno — structuring serverless functions for Stripe webhooks and transactional email
• Row Level Security — writing RLS policies in Supabase to enforce access rules at the database layer, not just the UI
• SwiftData's @Model and ModelContainer — local persistence with offline support
• Mac Catalyst — extending an iOS app to macOS with minimal additional code and the tradeoffs in that approach
• Web Speech API — browser-native voice input and graceful fallback for unsupported environments
• Chart.js on the web vs. SwiftUI Charts on iOS — similar mental models, very different APIs

Next Iteration

• App Store approval pending — once live, add the App Store badge and link to this page
• Add screenshots and a short demo video once the iOS app is publicly available
• Apple Watch complication for current timer state visible on the watch face
• Stripe Customer Portal for Business subscribers to manage and cancel their subscription without contacting support
• Webhook idempotency guard — current Stripe webhook handler doesn't deduplicate retries; adding a check against a processed_events table would make it bulletproof on retry storms

Outcome

Tally is the most architecturally complex thing I've built. Not because any single piece is difficult — timers, charts, and invoices are each manageable in isolation — but because making them work together across four platforms with two payment systems and a shared backend requires every layer to be correct at once. The cross-platform subscription sync is the part I'm most proud of: it's the kind of system that fails silently if you get it wrong, and getting it right required understanding how StoreKit, Stripe, Supabase Auth, and RLS all interact. Coming from iOS-only development, building the full-stack web side in parallel forced me to think about the product as a unified system rather than platform-specific features.