Evan Yu

I’ve made the server router be more like a builder pattern, and added support for (async) callbacks for expiry and public ACL

I’ve begun polishing up this project to be shipped. I’ve redesigned the projects page, made project slugs unique, and added it to the create project dialog, and also added the project list to the main sidebar.
Also made a bunch of other misc changes

Added file expiry/TTL for uploaded files. File validity is checked on download, and they’re lazily deleted by a cron job on the cf worker every 30 minutes.

I just implemented the SDK and did some major refactoring of the TUS implementation. There are 4 packages: @silo-storage/sdk-core, @silo-storage/sdk-next, @silo-storage/sdk-react, and @silo-storage/sdk-server

The Core SDK implements the core functions, like URL signing, different API request helpers etc…
The Server SDK implements the uploadthing-like file router ergonomics, including handling callbacks etc…
The Next SDK helps adapt the Server SDK to specifically nextjs, like creating the route handlers, etc…
The React SDK implements the React hooks like useUpload() and unstyled upload buttons/dropzones.

I did use AI to partially generate some of the SDK code, specifically the server SDK. This is because writing the typescript types would be very hard and cumbersome (see image 4)
I also used AI to quickly create an example nextjs app to demo the SDK. I plan on rewriting this part later.

Finally, while testing I ran into issues with my TUS implementation. Specifically with the upload resuming. Before, the worker stored all the metadata into KV, but after looking at Signal’s TUS worker implementation, I decided to refactor the TUS handler routes to instead use Durable Objects instead of storing state in a KV. This helps make recovery and keeping things tied together easier. Did use some AI to help with the migration.

Right now, it uses TUS chunked uploads, but i’m looking into streaming it

Built out the webhooks. It uses vercel queues to dispatch the webhooks with retries etc…
Webhook events are signed with a signing secret provided in the ui when creating the webhook.
(the ui is bad right now, but i’ll work on it later)

hours got unlogged again

I’ve revamped the environment system. Now each developer gets their own dev env, makes stuff easier. Also added a environment selector in the sidebar.
Finally, to handle deletion of environments with possibly tens of thousands of files, the worker offloads the deletion task onto cloudflare queues, which provides a durable way of ‘queueing’ the deletion of these objects. Not sure if that makes sense, it’s very late and I want to go to bed :p

Revamped the dashboard, and also added a time range filter to the analytics page.
Also a bunch of other stuff that I forgot about. Spent some time implementing a thing I forgot I already implemented on another computer :/

I’ve done a lot of work on the admin dashboard. The review dashboard uses z-score normalization to help us normalize reviewer scores to reduce bias.
Also hooked up the mailrelay.com api for marketing efforts.
Finally i’ve implemented an admin settings page for managing the state of applications (opening soon/open/ending)

Obligatory convex plug

I’ve implemented an application review dashboard. It scores applications with a 3 question rubric.
By default, it hides PII to prevent bias

I’ve added some cards to the dashboard, and also made the application form detect if it’s been edited somewhere else (convex ftw again)

Also minor ui fixes, like showing the question number in different places depending on the screen size

I’ve implemented a profile setup flow, and the application flow using Convex. Depending on which role the user selects, they are shown a different application form.

Did use some AI for animations (not fun :p)

I’ve set up better-auth with convex

Bootstrapped the project, and started work on the landing page. Currently i’m using motion.dev for a parallax effect, and some other scroll animations.

I’ve made it so that client SDKs can self-sign upload URLs without needing to hit /api/v1/upload for a presigned url.
Also API keys are no longer req’d to upload a file via the ui. It’s handled behind the scenes.

Added file/bandwidth analytics, and also revamped the sidebar + mobile support

The TUS protocol is now properly implemented, had to go around fixing some bugs etc…

file info ui

I’ve implemented the TUS protocol. It’s essentially a protocol for resumable file uploads, it’s pretty cool!

I’ve bootstrapped more of the project, added scoped API keys, etc

I’ve bootstraped a new project using turbo-kit. I’ve also set up a cloudflare worker microservice, and set up organization provisioning

I spent forever fixing a bug that I introduced in a previous commit that was meant to FIX bugs lmfao

I’ve added a stats display to the llm’s response message. (tokens per second, time to first token, etc)
Also made a bunch of minor ui changes/fixes

Made stream resume more robust and also made the optimistic message sending even faster

Finally tracked down the source of the error over to better-auth… This marks the fourth issue i’ve encountered with better-auth in my time using it that’s taken over 4h to debug.
(The record is https://github.com/better-auth/better-auth/pull/4724, which took well over 10 hours)

I’ve decided to migrate to tanstack start. This is because the app is mostly run fully client-side, and I want a better client-side routing experience. The only real next features I use are server actions and api endpoints.

Currently dealing with a weird bug: https://github.com/TanStack/router/issues/5196

Fixed an issue with create-turbo-kit not being able to run with npm.
To my reviewer, please make sure you are on node 22 and npm 10.9 (or use pnpm :D)

Also this devlog re-logs the 7h of work that was in my first devlog that got unlogged for some reason

I actually managed to do it… I optimized the send message latency from ~750ms to ~130ms! And on top of that, I implemented optimistic updates. Little writeup on what I actually did (copy-pasted from discord):

i rewrote the backend, the bottleneck was I was inserting sequentially as it’s basically a tree, and i need a parent node’s id before i can insert a child node
the solution i came up with is so dumb
basically I don’t want the client (browser) to control the id I give to threads and messages, as that allows for the user to supply basically whatever string they want
so I instead generate 3 ids, and I cryptographically sign them so I can “attest” to them being truly random. These ids are then passed to the client on page load (and regenerated on-demand)
then when the message is sent to the database (convex), it validates the signature and inserts the required rows with the ids that the client already knows about
all of this is so that when enter is pressed, the client already knows the ids of the thread and the message, so it can optimistically route to /chat/ and add their message onto the screen, making it look faster

tl;dr: I did some dumb sh*t with pregenerating ids on the server to make the browser redirect and show stuff faster before the rows are inserted in the database

Everything works, but it isn’t fast enough. At least it doesn’t look fast enough. Apps like t3.chat optimistically route the user to a new chat before it’s even created, so i’m going to do that too. However you can’t trust data created by the client, so i’m having the server generate and sign a id on page load, and that signed id is validated by convex when a message is sent, so the client and optimistically route itself to the new chat page before its even created.

PS. Antigravity sucks cursor GAPS it

Migrated from radix-ui to base-ui: https://base-ui.com/

My initial implementation of resumable streams was flawed and did not properly work. I spent two entire days debugging it and fixing it. Now it works!!

I’ve implemented a chat message input bar. It has token estimation, and a feature that highlights tokens. Additionally, any important chat state (i.e submitted, generating, error) is shown in the border of the chat input.

Did a bunch of work on basically everything, including the database schema, auth, and implemented the backend functions and routes, with resumable streams!
https://github.com/vercel/resumable-stream

I’ve implemented a core layout, and spent most of the time building the sidebar. It uses tanstack virtual lists (https://tanstack.com/virtual/latest) to dynamically load the chat history from convex.

Spent a bunch of time debugging weird issues with turborepo, and getting convex to work properly with better-auth (https://labs.convex.dev/better-auth/features/local-install)
Starting to think I should have gone with what i’m usually used to working with (postgres), or using something like clerk/workos

Spent nearly 4 hours figuring out convex and setting it up in a turborepo with better-auth. It finally works!

Currently trying to figure out whether to use convex ents

I’ve added more images to the blog post, and also implemented an image carousel

I’ve added a tech stack section, and completed the blog post that I never finished

Wrote some docs on the docker containers provided, added react-email (https://react.email/), and bumped next to version 16.1.0
The scaffold script now supports automatically removing unused dependencies

Had an LLM adapt my readme into a format suitable for documentation, made some changes and it’s now live:
https://turbo-kit.badbird.dev/docs/getting-started

I built out the docs section on the website, it uses contentful, mdx, tailwind typography, and rehype-pretty-code for code highlighting.

I’ve also added redis to the template, and a types package, exporting all db types there.

I built a landing page with nextjs for the template, it’s deployed at https://turbo-kit.badbird.dev/

Ignore this devlog, it is to track the 6 hours spent on the previous devlog that wasn’t tracked as the hackatime wasn’t linked

I’ve bootstrapped a new project off of create-t3-turbo, built a CLI to bootstrap a new project (with docker!), and started on building out the features I need on turbo-kit. This includes fixes for multiple bugs with tRPC + better auth, and the shadcn/ui CLI for monorepos