Guys, still grinding hard on OpenWord. The project is now way beyond a basic Wordle clone, I pushed both solo progression systems and real multiplayer foundations with rounds, rooms, and live state flow.

What’s new:

Backend:

• Solo progression complete: save game endpoint, score persistence, user game history, and stats aggregation
• Multiplayer API live: create room, join room, fetch room state, host-only start, submit guesses, leaderboard, and finish game
• Multiplayer runtime state: in-memory active match tracking + DB-backed room/player records
• Round-based multiplayer support added: total score tracking and round score storage model
• Better API context: DB is wired into protected procedures for richer server features

Frontend:

• Solo play refactor: split into focused tabs/components for settings, active gameplay, and score results
• Better guess UX: per-letter grid input, keyboard/backspace behavior, hinted locked slots
• Score screen improved: richer breakdown, result summary, and auto-save flow for logged-in users
• Dashboard upgraded: real user stats and recent game history views with loading/error/empty states
• Multiplayer page shipped: lobby, create/join room flow, waiting room, and game screen routing state

Database:

• Added persistent solo Game model with analytics-ready fields
• Added user role field for future access control
• Added multiplayer schema models: Room, RoomPlayer, MultiplayerGame
• Added support for numRounds/currentRound and cumulative + per-round scoring structures

Guys, I’ve been grinding again. I put some spice on OpenWord to make it more complete in the game loop with stats, history, persistence, cleaner architecture, and way better solo gameplay UX.

What’s new:

Backend:

• Persistent Solo Match Data: Added full game save flow for logged-in users (difficulty, word, result, guesses, score, bonuses, time, hints, attempts left)
• Dashboard APIs: Built protected endpoints for personal stats and paginated game history
• Hint Engine: Added server-side hint support with limits, random unrevealed-letter reveal, and validation guards
• Expanded Game Config: Start-game now supports custom attempts, hint limits, and language selection
• API Context Upgrade: Wired DB into tRPC context for richer protected procedures
• Better Error Handling: Secret word fetch now throws explicit server errors instead of masking failures

Frontend:

• Major Play Screen Refactor: Split the monolithic play UI into focused components (Settings, Game, Score)
• Better Guess Input UX: Added grid-based per-letter input with keyboard navigation, backspace behavior, and hint-locked letter slots
• In-Game Hint Controls: Added hint button + live usage counter with smart disable states
• Score Screen Upgrade: Shows full scoring breakdown, revealed word, and auto-saves finished games for authenticated users
• Word Meaning Lookup: Added post-game dictionary definition fetch for revealed words
• Scoring Rebalance: Win/loss scoring paths now differ, with hint penalties and fairer low-score handling
• Dashboard Revamp: Replaced placeholder content with real stats cards + recent match history
• Shared Component Cleanup: Reorganized common UI pieces (header/footer/loader/word tiles) for maintainability

Database:

• New Game Model + Migration: Added persistent game table with analytics-ready fields and indexes
• User Role Support: Added role column for future access/feature expansion

Guys, this is the final devlog before CivicSprint v1.0.0-Beta.

What started as a rough idea is now a working full-stack platform with real role-based flows, collaboration, and security baked in.

Current flow is solid:

Sign up → verify email → login → role dashboard (Admin / Coordinator / Volunteer) → create/join sprints → manage tasks → comments/activity tracking → approvals + notifications.

What made it into Beta:

Backend:

• Full auth system with verification, password reset, session validation, and account status handling (active/suspended/deleted)
• Multi-device session management (view sessions, revoke one, revoke all)
• Two-factor auth (TOTP + backup codes)
• Sprint + task APIs with role checks and coordinator ownership rules
• Task comments + activity timeline (who changed what and when)
• Approval workflow with history and status transitions
• Notification module (read/unread, unread counts, mark all read)
• Role-based dashboard endpoints (admin/coordinator/volunteer)
• Prisma schema matured with major migrations (auth, task collaboration, notifications, 2FA, volunteer-user linkage)

Frontend:

• Role-based dashboards and protected routes
• Interactive map-based location selection + sprint map views
• Sprint detail/create/edit flows stabilized
• Task collaboration UI (comments + activity log)
• Notification center with polling + unread badge
• Full profile management (edit profile, email change flow, password change, sessions, 2FA settings, account deletion)
• Auth UX improvements (steppers, verification/reset flows, cleaner redirects and error handling)
• UI polish across cards/forms/states/loading/skeletons

Where we are right now:

Core Beta features are in and usable end-to-end for all three roles.
Main remaining work is polish/perf: pagination in larger lists, deeper QA pass, and deployment hardening.

Big milestone. v1.0.0-Beta is ready to ship.

Alright, been putting in serious work on this project. Built out a complete Wordle-style guessing game from the ground up with full authentication, game mechanics, and a polished UI.

What’s new:

Frontend:

• Game Flow: Interactive play page with real-time game state management, input validation, and status tracking (playing/won/lost)
• Animations: Letter component with smooth flip animations triggered on guess submission, dynamic letter status updates (correct/present/absent)
• Word Display: WordWrapper component rendering word grids with color-coded feedback system (green/yellow/gray)
• Auth System: Full sign-in/sign-up forms with email/password validation (min 8 chars), form state management with TanStack React Form, toast notifications for success/errors
• Dashboard: Protected dashboard for authenticated users, integration with TRPC for private API calls
• UI Suite: Beautiful shadcn/ui components (buttons, inputs, cards, labels) + dark mode toggle
• Responsive Layout: Mobile-first design with proper spacing and TailwindCSS utility styling

Backend:

• Game Logic: Solo game mode with word selection (random or specified length), 6-attempt limit, guess validation, comprehensive feedback system
• Game State Management: Game state persistence with unique game IDs, attempt tracking, guess history with feedback records
• Word System: Fallback word list (20+ words) for development/testing, word length flexibility (defaults to 5)
• Protected Routes: User session validation, private data endpoints, authenticated game endpoints
• API Structure: TRPC procedures for game operations (startGame, submitGuess, getGameState), type-safe client integration

Database:

• Auth Models: User, Session, Account (multi-provider support), Verification (email verification tokens)
• Email/Password Auth: Dual authentication support via Better Auth, session tracking with IP/user agent
• Schema: Proper relationships and cascading deletes for data integrity

Everything is fully typed with TypeScript, running in a monorepo with Turborepo for optimized builds. Next.js front, Express back, TRPC for type-safe APIs.

Guys, I’ve been grinding. Added a ton of auth/security features, full profile management, interactive maps, task collaboration, and proper role-based dashboards.

What’s new:

Backend:

• 2FA: Full TOTP implementation with speakeasy + QR codes, backup codes, enable/disable/regenerate
• Session Management: Multi-device tracking (browser, OS, IP, location), view all sessions, logout specific devices or all devices, activity tracking
• Profile Management: Change email, change password, delete account (sets accountStatus to DELETED)
• Task Collaboration: Comments system, activity log tracking every field change (who changed what when), notifications for assignments/comments
• Notifications Service: Real-time polling, unread counter, mark read/unread, mark all read, supports task/sprint/approval events
• Dashboard Endpoints: Role-specific (admin sees pending approvals + user stats, coordinators see their sprints + status breakdown, volunteers see assigned tasks)
• Account Status: ACTIVE/SUSPENDED/DELETED enum, blocks login for deleted/suspended accounts

Frontend (huge UI improvements):

• Interactive Maps: LocationSelector with MapLibre GL + reverse geocoding (click map → get address), SprintLocationsMap showing all sprints with markers
• Profile Page: Tabbed interface (profile/email/password/sessions/2fa/delete), 2FA setup with QR code + stepper
• Task Collaboration: TaskComments + TaskActivityLog components showing full audit trail
• NotificationCenter: Bell icon, unread badge, 5s polling, toast notifications
• Dashboard Pages: Custom for each role (admin/coordinator/volunteer) with stats + recent activity
• Auth Flow: SignupStepper, TwoFactorVerify, ProtectedRoute wrapper

Database (8 migrations):

Email verification, password reset, task comments/activities, account status, notifications, volunteer-user relation, two-factor auth

Guys, little update time. Backend is basically complete now (for the basic features), went from skeleton NestJS to fully working API.

The flow works end-to-end:
Sign up → Email verification → Login → Dashboard → Create/join sprints → Manage tasks → Request approval → Admin reviews

What I built since last time:

Backend (where most time went):

• Full auth with session tokens + email verification (6-digit codes, 15min expiry, can’t login until verified)
• Mailer service with nodemailer + SMTP + HTML templates (verification, welcome, approval notifications)
• Sprint/Task CRUD with proper role checks (coordinators only edit their own sprints, admins do everything)
• Approval workflow: coordinators request → sprint goes “under-review” → admin approves/rejects → notifications sent
• Search endpoint (queries sprints/tasks by title/description/location)
• Volunteer endpoints for profiles
• Switched PostgreSQL to MySQL, added email verification migration

Frontend:

• /verify-email page with token handling, auto-login, resend button
• /showcase public landing page with stats
• /admin/approvals page for reviewing requests

Still needs work:

• No pagination yet. Admin approval UI is basic. No real-time notifications or image uploads. Haven’t deployed, still local on 3000/3001.

But the core works – sign up, verify, create sprints, assign tasks, request approvals, admins approve. All three roles functional end-to-end.

Guys, things moved fast and the project is growing up even if I have been quite busy lately. TogetherToGo is turning into a real full-stack app: a platform where people create short community “sprints” (cleanups, city guides, pop-up cultural events) and others join as volunteers.

The user flow now is:
User -> Log-in -> Choose role (Admin / Coordinator / Volunteer) -> Create or join sprints -> Manage tasks / Request approvals

What I’ve done since the last update:

• Frontend: finished role-based UI and guards, create/edit controls now appear only for coordinators/admins; volunteers get a read-only experience. Protected pages (dashboard, sprint details, volunteers) redirect unauthenticated users to /login.
• Auth fix: resolved a local-Dev 401 by removing the Secure cookie flag and adding a localStorage fallback + Authorization header support for sessions.
• Backend (started): scaffolded a separate NestJS service at togethertogo-backend.
  • Installed NestJS and Prisma, added PrismaService and PrismaModule.
  • Added Prisma schema (User, Session, Sprint, Task, Volunteer, ApprovalHistory) and .env for a local PostgreSQL connection.

What’s next (short term):

• Implement core services & controllers: login/register (JWT), sprint CRUD, volunteer endpoints, approval request/approve flows
• Add CORS and connect frontend to backend (API on port 3001)
• Seed minimal demo data and test end-to-end flows for all roles

The idea is still evolving, but the foundations are in place. For now I’ve focused on secure auth, role-based UI, and a proper backend skeleton.

Have a look and tell me what you think!

Hi guys, since the last devlog I focused on polishing the browser extension and finishing a bunch of backend features so your captures actually behave like a proper cloud-first snippet manager.

Highlights

• Browser extension: save any selected text from any page, quick-access floating toolbar + right‑click context menu, automatic language detection, and silent token refresh so sessions don’t randomly die. Download from the releases page. ✅
• Backend & sync: conflict-safe sync flow + conflict metadata, snippet versioning (create/list/restore), and snippet sharing with expiring tokens.
• Device & auth: per-device refresh token support and device fingerprinting for better session control.
• VS Code extension: full sidebar + detail view (copy/insert/search), login commands, and auto-sync settings (snippetvault.autoSync, snippetvault.syncInterval).
  Welcome to SnippetVault v1.2!

Hi guys, since the last devlog I’ve been developing the browser extension that allows you to save any selected text on any webpage that will be then synced to your account’s Vault once you log in. You can download the extension by navigating to the releases page and follow the instructions.
The extension also allows you to have a quick access to SnippetVault and save your snippets to a specific folder.
Last but not least, I’ve worked on a few UI tweaks that I completely missed before, such as:

• Long descriptions that caused the app to error or overflow the snippet card -> Warn the user, then truncate to 100 characters
• The “+ New snippet” button on some screens was floating in the middle of nowhere -> Remove horizontal alignment from the search bar row
• Some scrollbars were overlapping -> Removed them
  For now, I think it’s everything, lemme know what you think. 👀
  Stay tuned for code editor extensions…

Guys, I’m so excited that I can finally start working on a real-world project such as TogetherToGo. It’s basically a platform that allows user to create small “sprints” to improve the environment, to advertise a unique aspect of their city, to promote a cultural event etc.
The ideal user flow that works for me is:
User -> Log-in -> Choose your role (Organizer, Volounteer) -> Organize events/Apply for events
The idea is still a bit raw, but I’m sure it will improve as soon as I run into the first issues. For now, I’ve worked on a basic client-side UI to add and edit Sprints. Have a look and tell me what you think!

I haven’t edited any code since the last devlog except some configuration files for deployment. Currently I’m hosting SnippetVault on my VPS, I don’t have any domain or SSL certificate for now, but I’m proud to introduce you to SnippetVault v1.1. Wish me luck and stay tuned!

So… short status update from the trenches. Auth is done enough to be dangerous: NestJS + JWTs, email verification, sign-in, the whole Postman-grind until the happy path behaved. Then I opened the door to being nice to users and immediately stepped into Hybrid Storage hell.
Guests live in localStorage and it’s instant, offline, zero friction. But the moment someone signs up the app has to act like a translator between a fast local cache and a MySQL-backed source-of-truth. That turned a simple snippets app into a small distributed-data problem.

What I changed, and why it hurt a little:

• Sync model: I added a local operation queue, optimistic updates, timestamps/versioning, and server-side conflict detection so offline edits don’t vanish or silently overwrite newer data.
• Pause-and-resume: If the JWT expires mid-sync, the sync loop now pauses, persists the queue, and won’t retry destructive operations until re-auth. That prevented partial clobbers and saved my sanity.
• Initial Sync heuristics: when a user converts from Guest → Authenticated I added heuristics: push if server empty, attempt diff+merge if both sides have history, and surface ambiguous conflicts to the UI instead of guessing. I also added a lightweight version-vector / lastModified strategy so merges stay deterministic.
• UX for conflicts & migration: I built dialogs to handle per-snippet conflicts and migration previews so users can choose keep-local / keep-cloud / merge rather than being surprised.
• Mobile Navigation
• User settings and account management
  That’s all for now… Enjoy SnippetVault v1.1!

So… as I said in the last devlog, I’ve been creating an entire authentication system from scratch by setting up a nestjs backend with jwt tokens to encrypt session data. After building the basic user authentication flow (Sign Up -> Email verification -> Sign In), I tested it using Postman and after some iterations I managed to get it to work as I expected. But the problems hadn’t even started yet…The real challenge began when I tried to implement what I call “Hybrid Storage.” I didn’t want to force users to create an account just to try the app, but I also wanted power users to have their snippets synced across devices.

My logic became a bit of a branching tree:

• The Guest: If there’s no JWT, useSnippets() talks exclusively to localStorage. Simple, fast, offline.
• The Authenticated User: This is where the “pain” lives. I’m using localStorage as a high-speed cache for offline changes, while the NestJS backend acts as the source of truth.

The headache isn’t just the API calls; it’s the Synchronization. I had to figure out: When does the local data “graduate” to the cloud? If I’m offline and I edit a snippet, I save it to localStorage. But the moment the connection returns (or the user logs in), I have to trigger a sync event that pushes those local changes to my MySQL database without overwriting newer data.

Managing the state between the NestJS JWT guards and the React state has been a balancing act. If the token expires while I’m mid-sync, I have to catch that error, pause the sync, and keep the data safe in localStorage until the user re-authenticates. It’s no longer just a “Code Snippet” app; it’s a data-consistency project.I’m currently wrestling with the “Initial Sync” logic, that moment a user signs up and I have to decide whether to push their existing local snippets to the cloud or fetch what’s already there.

Soooooo… Since the last devlog I’ve been thinking on how to sync your snippets through cloud and dividing each user’s snippets through authentication (I’m also working on a browser extension that allows you to create a new code snippet by selecting text on a page). The thing is that I never worked on authentication and authorization. Probably the best way to learn how those work is by creating a project that forces you to learn them. In the end, I’m here to learn, so here’s what I’ve been up to:

• Frontend (Web Page/Extension) -> Just login/signup interface + Snippet Data collection
• Backend (NestJS + MySQL) -> Gets the data from the frontend, stores it and manages it
  Wish me luck as I’m trying to learn NestJS, MySQL, JWT and session management all at the same time. I’ll be here documenting all the pain along the way.

First question after the first log: “How do I keep every component in sync without prop drilling?” I hit a state-staleness bug: edits and creates updated local state but didn’t reflect across components. The fix was to lift the hook into a single source of truth—SnippetsContext—so useSnippets became a shared provider (SnippetsContext.tsx). Problem solved: list, editor and form now see the same data instantly.

Then I improved UX: replaced textarea with Monaco in the form (SnippetForm) so creation/editing gets full syntax highlighting; added in-place editing in SnippetEditor (toggle to switch read-only → edit). I also wired the form to return the saved snippet ID so the parent can auto-select it after create/update.

Filtering & search became richer with a useSnippetFilters layer: query, tags, language, favorites and sorting. SnippetList now renders filtered results and shows proper empty/loading states.

Finally: import/export JSON, keyboard shortcuts, sonner toasts for feedback, and robust localStorage utilities for persistence. From hook to context to full Monaco-powered editor—snippets feel instantaneous and polished. What’s next? Export presets or cloud sync?

First of all, the first question that came up to my mind when I started this project was: “What is a code snippet?”. To me, it was a block of highly reusable code, easy to maintain and scale, that I use frequently. Where should I save it without using a database? Easy, browser’s local storarge. So I started by defining the schema of a snippet and the hook that I would be using for the next hour to create, update, save and delete snippets: useSnippets()
Then it was the time to develop the UI, quick shadcn components, Monaco Editor to edit and visualize the code properly, a form to create/edit snippets and that’s it. Or is it?