Forem: Kepler Jay

Seton — A focus timer that turns your hours into assets

Kepler Jay — Sat, 10 Jan 2026 04:27:23 +0000

The Problem

You probably spend a lot of time on screens.

If time is money, the hours we spend are capital expenditures. We should be careful about how we allocate them, because they're the capital we have.

Peter Drucker said: The first step toward executive effectiveness is to record actual time-use.

But it's not easy. We generally track time on the spot with a timer, or just a clock. It doesn't give us a sense of long-term progress.

Most timers on app stores have limited features, such as pomodoro. Some apps are too complicated. We don't need calendar or team features, which sacrifice simplicity for personal use.

The Solution

That's why I built Seton - a focus timer that visualizes your time spent like an asset you’ve invested.

https://seton.run/

All you need to do is press "Start" for the activity you're working on. The activity can be reading, writing, meditation, or anything else.

When you complete a focus session in the app, it accumulates. You can look back on your time spent with charts. Celebrate your progress like "I've spent 100 hours reading this year!" You can configure how many minutes to focus and break, and number of cycles of sessions.

It's very simple, but highly effective. The more you record your time, the better you will be at managing it. That will make you more productive for sure.

The Philosophy

1. Frictionless: No need to sign up. Just press "Start".

2. Privacy: Data is stored in the browser. No syncing feature for now.

3. Low-cost: It runs on Cloudflare to minimize costs. It's free for the time being.

If you like Seton, please share it with your friends. Let me know what you think on X (@keplerjst).

Time is money, and life is an accumulation of time. In that sense, I think everybody is an investor. Good luck on your investment journey!

Hono + Preact - The Ultimate Starter for Web Apps I Can Think Of

Kepler Jay — Mon, 15 Dec 2025 01:19:27 +0000

Full-stack frameworks are everywhere. Next.js, Nuxt, Remix—they offer incredible developer experience and get you from zero to production fast. But there's a trade-off we occasionally talk about.

When you deeply depend on a framework, you inherit its risks. Security vulnerabilities, breaking changes, deprecated APIs. Overtime, you'll spend more time keeping up with the framework than building your product. And let's be honest: the JavaScript ecosystem moves fast. Too fast, sometimes.

Many developers want "lightweight" alternatives. Fewer abstractions, less magic, more control. But the convenience of batteries-included frameworks is hard to leave behind. React, Next.js, Vercel—they're deeply intertwined, and once you're in that ecosystem, switching costs feel enormous.

The Rise of Lightweight Alternatives

Things are changing. Lightweight frameworks are gaining real momentum.

Hono is a perfect example. Created by a Japanese developer, it started as a simple API framework for Cloudflare Workers. But it's grown into something more—with RPC support, JSX rendering, and SSR capabilities. It's fast, minimal, and runs everywhere: Cloudflare, Deno, Bun, Node.js.

Preact follows a similar philosophy. It's essentially React's API in a 3KB package. No Concurrent Mode complexity, no use() hooks to wrap your head around. For many applications, Preact is all you need—and it's refreshingly simple.

Together, Hono and Preact feel like the right foundation for developers who want power without the weight.

The Problem: A Gap in Resources

However, here's where it gets tricky.

Most tutorials, Stack Overflow answers, and blog posts focus on mainstream tools. Want to build a full-stack app with Hono and Preact? Good luck finding consolidated resources. You're on your own, piecing together scattered documentation and GitHub issues.

The hardest parts? SSR, hydration, and routing.

How do you render Preact components on the server with Hono?
How do you hydrate them on the client without duplicating your route definitions?
How do you handle data loading in a way that works for both server and client?

These aren't impossible problems, but they require digging. And if you just want to start building, that friction is frustrating.

Introducing Hinoco

So I built Hinoco—a full-stack template for Cloudflare Workers using Hono and Preact.

Why? I'm planning to build one Micro SaaS per month in 2026. Rather than solving the same infrastructure problems repeatedly, I wanted a solid foundation ready to go. Something that handles the boring parts so I can focus on the product.

Hinoco is that foundation.

Demo: https://hinoco.keplerjst.workers.dev/

GitHub: https://github.com/keplerjst/hinoco

What's Included

SSR + Hydration + Routing — Server-rendered pages that hydrate seamlessly on the client
Hono — Lightweight, fast API framework
Preact — React-compatible UI in 3KB
Vite — Fast builds and HMR during development
Tailwind CSS — Utility-first styling with dark mode support
Cloudflare D1 + Drizzle ORM — SQLite at the edge with type-safe queries
GitHub Actions — Automatic deployment on every push to main

Project Structure

  src/
  ├── server.ts          # Hono server entry point
  ├── client.tsx         # Client-side hydration entry point
  ├── App.tsx            # Root Preact component
  ├── routes.ts          # Route definitions
  ├── style.css          # Global styles (Tailwind)
  ├── api/
  │   └── index.ts       # API routes (/api/*)
  ├── app/
  │   ├── routes/        # Page components with loaders
  │   │   ├── home.tsx
  │   │   └── about.tsx
  │   ├── components/    # Shared components
  │   │   ├── Header.tsx
  │   │   └── ThemeProvider.tsx
  │   └── NotFound.tsx   # 404 page
  ├── db/
  │   └── schema.ts      # Drizzle schema
  └── lib/
      └── ssr.tsx        # SSR middleware

Getting Started

# Clone the repository
git clone https://github.com/yourname/hinoco.git
cd hinoco

# Install dependencies
pnpm install

# Create a D1 database
npx wrangler d1 create hinoco-db

# Run migrations locally
npx wrangler d1 migrations apply hinoco-db --local

# Start development server
pnpm run dev

That's it. You're running a full-stack Hono + Preact app on Cloudflare Workers.

Closing Thoughts

I have experience with Next.js, but this was my first time building something serious with Hono and Preact. It's a simple template—intentionally so. But it removes the headaches that come with starting from scratch.

If you're tired of framework complexity and want to try something lighter, give Hinoco a shot. Fork it, modify it, make it yours.

And if you build something cool with it, I'd love to hear about it.

Why I'm Building 12 Micro-SaaS in 12 Months (as a Former Founder)

Kepler Jay — Tue, 09 Dec 2025 14:05:22 +0000

I founded my startup in 2017, and after an 8-year grind, I finally sold it for a few million dollars in 2025.

The journey was... intense. It was a chaotic mix of organizational struggles, fundraising hurdles, key employees leaving, and navigating endless customer demands. While I’m grateful for the exit, the process taught me a hard truth: This isn't the game I want to play.

At my core, I am a developer. I believe in the power of one person building something great. I realized I’d rather spend my energy crafting excellent products than exhausting myself with fundraising decks and middle management.

The "Golden Handcuffs" and The Void

Currently, I’m in a lock-up period. I have to commit to the acquirer's management team, which means I can't launch anything publicly under my real name yet. My focus is fragmented, sliced thin between corporate reporting lines and my responsibilities at home.

I have a backlog of product ideas I’m dying to build. But most of them are "Big Ideas"—complex platforms that require massive context and energy. With my current fragmented schedule, they are impossible to execute.

Meanwhile, the world is changing at breakneck speed with the rise of AI. Watching the tech landscape evolve while I sit on the sidelines, unable to ship my own ideas, is frustrating. It feels like FOMO on steroids.

The Shift: From "Big Bang" to "12 Experiments"

So, I decided to flip the script.

Instead of seeing this lock-up period as a prison, I’m treating it as a "Research & Development" sabbatical.

I won't try to build the "next big thing" right now. Instead, I want to build small. I want to experiment. My goal is to release one Micro-SaaS every month throughout 2026. That’s 12 products in 12 months.

The plan is simple: Turn small ideas into tangible tools, throw them out into the wild, and see if they stick. If I find a seed that grows, I can double down on it later.

The Enemy: Context Switching

We all know that shipping is harder than it looks. A prototype might take two days, but the polish—fixing bugs, handling edge cases, writing copy—takes weeks.

This is especially true when you have a "day job." Trying to remember where I left off in the code after a long day of meetings is mentally draining. Context switching kills momentum. By the time I reload the project into my brain, my passion has often evaporated.

To combat this, I’ve established strict constraints.

The Constraints: Web Only, Fixed Stack

Rule #1: No Mobile Apps, No Desktop Apps. Mobile apps are a nightmare of App Store approvals and review processes. Desktop apps (even with Electron or Tauri) add too much friction for the user to just "try it out." The Web is still king for MVPs. If the concept works on the web, I can build native versions later.

Rule #2: One Stack to Rule Them All. I love the TypeScript ecosystem. For this challenge, I need speed and low overhead. I’m skipping the "which framework should I use?" debate and locking in my stack for the entire year:

Frontend: Preact (React is great, but I prefer lightweight libraries. Preact gives me the React ecosystem without the bloat.)

Backend: Hono (Standard-compliant, fast, and runs anywhere.)

Infrastructure: Cloudflare (Workers, Pages, D1).

While Next.js is the industry standard, I find it can be heavy outside of Vercel. I want to keep things raw, cheap, and fast. Cloudflare’s edge network is perfect for this.

The Road Ahead

In 2026, I will be a machine that turns coffee into Preact and Hono code.

I once tried building a desktop app with Tauri and got bogged down in the complexity. I learned my lesson. In the web world, deployment takes seconds.

The infrastructure is solved. The constraints are set. All that’s left is to polish the concepts and distill them into simple, valuable solutions.

I’ll be documenting this journey—the code, the metrics, and the inevitable failures—right here.

Let’s build.