The Version We Didn't Put in the Demo: Slate's Honest Scorecard
98 commits, under one cent of AWS spend, an authorization model you can read in 48 lines - and a timetable grid that's 1,464 pixels wide on a phone. A judge-facing audit of what Slate actually gets right, what it doesn't yet, and exactly what we'd fix first.
Our first post about Slate is a build log, and build logs have a selection bias: you write about the thirty lines that worked, not the ones you didn't get to. This one is the other half. Ninety-eight commits in, with the app live and the data real, we sat down and asked the question a judge is going to ask anyway - what's actually still wrong with this - before someone else did.
The answer split cleanly into two piles: things that are correct on purpose, and things that are wrong for a reason we can name. There's a third pile we don't have, which is things that are wrong for a reason we can't name, and that distinction is the entire point of this post. A project that's finished lying about its gaps is more fundable than a project with no gaps, because the second one doesn't exist yet.
What actually holds up
We're not going to re-run the whole build log here - that's the first post. But three things are worth stating plainly, because they're the parts we'd bet on if a judge opened the repo and started clicking around specifically to break something.
The authorization model is a file, not a feeling. Every write to a timetable goes through one Cedar policy, 48 lines, evaluated server-side inside a Lambda, with the caller's section resolved from their Cognito-verified email rather than trusted from the request. You can
grep cedar in CloudWatch and see the allow/deny line for anything anyone has ever tried. We've tried to break this ourselves — sending a section list the client isn't supposed to have - and the server throws it away and re-derives the truth. That's not a claim; it's reproducible.The parser catches its own mistakes. The L-T-P-S deficit check described in the first post isn't a nice-to-have - it found 49 real under-reported class durations in our own ingested data before a single student saw the app, and it flags errors in the institute's source spreadsheets, not just ours. A system that can be wrong loudly is worth more than a system that's usually right silently.
We know what a cent looks like. Four days of development, imports, re-imports, and a live demo, entirely on Cognito, AppSync, DynamoDB, S3 and five Lambdas - no EC2, no NAT Gateway, no idle compute - cost less than one US cent. That's not a target we hit; it's what "no server sitting there being wrong for you" costs by default. It's the one number in this whole post that required no judgment call to verify, only a billing dashboard.
Everything else in this post exists because we spent our four days on those three things, in that order, and the clock ran out before it ran out on everything.
What we're lacking, specifically
Not "could be more polished." Specifically.
1. We defined the indexes and then didn't use them
Here's
find-slots , today, reading the offerings table:// amplify/functions/find-slots/handler.tsasync function scanAll(table: string): Promise<Row[]> { const items: Row[] = [] let start do { const page = await ddb.send(new ScanCommand({ TableName: table, ExclusiveStartKey: start })) items.push(...(page.Items ?? [])) start = page.LastEvaluatedKey } while (start) return items}
Every one of our five Lambdas reads its tables this way - a full
ScanCommand , paginated, every time. At our current data size (a few thousand students, a few hundred offerings) it's invisible. At ten times that it's a real bill and a real latency problem.The part that actually stings is that we already fixed the schema:
// amplify/data/resource.ts.secondaryIndexes((i) => [i('offeringKey').sortKeys(['day', 'startTime']), i('term').sortKeys(['day'])])
Those GSIs are deployed, right now, on the live table. Nothing queries them. We defined
PK OFFERING#<key> / SK <day>#<startTime> as the natural access pattern for "give me one offering's meetings," and every handler still asks DynamoDB for the entire table and filters in memory afterward. That's not a missing feature - it's a finished half-measure, which is a worse state to leave code in than not having started, because it looks done from the schema file and isn't done in the five places that actually run.The fix is scoped and known: swap five
scanAll calls for QueryCommand against the indexes that already exist. No new infrastructure, no new design decision — just the afternoon we didn't have.2. One JavaScript file, and it's over a megabyte
dist/assets/index-D8Ndjihg.js 1,036.59 kB │ gzip: 288.35 kB
(!) Some chunks are larger than 500 kB after minification. Consider:- Using dynamic import() to code-split the application
That's Vite's own build output, not a hypothetical. Every admin screen, every student screen, the Cedar-adjacent editor and the CSV export all ship to a first-year student's phone on first load, whether they're a student who only ever opens "My Timetable" or an admin who never touches the upload flow. A route-based
React.lazy() split - admin bundle separate from student bundle - is a known pattern, not a research problem. We didn't do it because every hour before the deadline went to whether the data was right, and a slow first load is recoverable in a way a wrong timetable isn't. Right prioritization, real cost.3. The screen everyone actually opens doesn't fit a phone
.timetable-grid { min-width: calc(64px + 10 * 140px); /* 1,464px, minimum */}
That's the main student screen - the one thing every user opens on day one. It's a ten-column weekly grid, and it needs at least 1,464 pixels to render without crushing itself. Almost every student at IIIT Allahabad is going to open this link on a phone first, and a phone is going to hand them a horizontally-scrolling table, which is a worse experience than the WhatsApp poll we're trying to replace.
This is the one gap we'd fix before the indexing problem if we had one more day, because it's not a performance nit, it's the product not working for its actual primary device. The honest fix isn't "make the table smaller" - a compressed ten-column grid is unreadable at any width - it's a second, mobile-specific view: one day at a time, vertically stacked, with day-switching tabs instead of side-by-side columns. We know the shape of the fix. We didn't build it.
4. Nothing pushes — everything waits for a click
We looked for a GraphQL subscription anywhere in the codebase while writing this post. There isn't one. AppSync supports
onCreate / onUpdate subscriptions natively - Amplify Gen 2 would generate the client code for free - and we never wired it up. The practical effect: if a CR cancels a class while another student already has the timetable open, that student sees the old timetable until they navigate away and back, or refresh. The data is never wrong; it's just not live. For a product whose entire pitch is "stop finding out by accident," that's a real gap in spirit, even though the read-after-refresh guarantee is fully correct.5. One person's diligence is the entire test suite
docs/TESTING.md is a 29-item manual checklist against a known seeded account. It's thorough, and it's honest about being manual. It is also the only thing standing between a code change and a regression. There's no CI workflow in this repository - no .github/workflows/ at all - and no automated test for the interval-intersection logic that's the actual product. The Cedar policy has no unit test asserting "a CR of Section A cannot cancel a Section B class" in code; it has a person clicking through that scenario once and writing down what happened.We'd rather admit this than dress it up: for a four-day event with three people, we spent the testing budget on manually verifying real data (the 49-duration audit, the registration-matching spot checks) rather than on scaffolding a test runner. Given the choice again, under the same clock, we'd make the same trade - wrong data is worse than an untested function - but it's a trade, not a strength, and the very next thing we'd add is
vitest on the pure functions in find-slots and the Cedar policy fixtures, because those don't need a deployed backend to test.6. The interface is inherited, not designed
Slate's visual system - the type pairing, the card shadows, the green accent, the topbar layout - was ported wholesale from a sibling project one of us had already built, and then refined in place rather than designed from Slate's own brief. That's a legitimate way to move fast, and the result is coherent rather than clashing. But it means the thing entered for a Best UI prize is a real logo and a set of honest interaction refinements sitting on top of someone else's design decisions, not a system built for this problem. We'd rather say that than let a screenshot imply otherwise.
7. PDF ingestion still doesn't exist
This one's already in the README, and we're restating it here on purpose rather than letting a single disclosure buried in a "How ingestion works" section count as closed. Amazon Textract and Bedrock were the planned path from PDF to structured data; the AWS account's Bedrock quota came back zero on day one and never moved. The
.xlsx reader that replaced that plan is real, validated, and in production - but it only reads spreadsheets. A department that only has a scanned PDF timetable cannot use Slate today. That's not a rounding error in the pitch; it's a real ceiling on who this works for right now.
What we'd build next, in order
Not a wishlist - an order, because with a fixed amount of time the order is the decision:
- The mobile timetable view. This gates whether the primary user can use the primary screen at all. Everything else is an improvement to something that already works; this is a fix to something that currently doesn't, for the majority device.
- Wire the five
scanAllcalls to the GSIs that already exist. No design work left to do - it's translation from one AWS SDK command to another, function by function.
-
vitestonfind-slots's interval math and the Cedar policy, as fixtures. Neither needs a deployed backend. This is the highest test-coverage-per-hour available to us.
- Route-based code splitting, admin and student bundles apart, because it's mechanical once the first three are done and it's the cheapest of the four.
- GraphQL subscriptions on
ScheduleChange, last, because "correct after a refresh" is a real guarantee and "correct without one" is a nice-to-have layered on top of it, not a replacement for it.
Then, only once Bedrock quota is actually non-zero - verified with a real
InvokeModel call, not the console - revisit PDF ingestion. Not before, because architecting around a permission you don't have yet is exactly the mistake the first post is about.
Why we're publishing the gap list
The judging criteria for this event score five things: idea and impact, whether it's built on AWS, what we learned, whether it actually runs, and the video. Nowhere does it say "no known issues" — it says execution, and "one feature that runs beats five that almost do." A team that can point at a
ScanCommand and say exactly which QueryCommand replaces it, and why they didn't do it yet, has understood their own system more precisely than a team with a longer feature list and no idea which corner is load-bearing.Slate does the one thing it claims to do - turn "find a free hour across three timetables and a professor's own schedule" from a two-day WhatsApp poll into a ranked list with reasons, in seconds, on a live URL, for under a cent. Everything in this post is the list of what stands between that and a system we'd trust with the entire institute's timetable unattended. We'd rather hand a judge that list ourselves than have them find the first item on it by clicking around.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article