When an event weaves together cutting-edge AI, nuanced behavioral science, gamification, and habit formation, it rises above the ordinary hackathon. It becomes a canvas for a generation crafting tools to navigate life with purpose and poise. The LifeQuest Balance Hackathon 2025 was precisely that—a three-day marathon where coders, designers, and visionaries united to forge solutions for thriving in the modern world.
Every submission was a marvel—fully deployed, demo-ready, and polished to perfection. There were no half-baked prototypes or skeletal interfaces—just robust, thoughtful systems built with precision and passion.
Igor Chumikov, the lead judge whose reputation for iOS excellence inspired participants to elevate their craft, guided this endeavor with a keen eye and seasoned expertise.
Meet the Judge
An iOS Technical Expert at Yandex Practicum and a seasoned developer at Consultant Plus, Igor Chumikov is a cornerstone of the iOS development community in Russia. With years of experience building and refactoring high-profile apps like Consultant Plus and Ozon Seller, Chumikov excels in SwiftUI, UIKit, MVVM architecture, and rigorous testing practices. His work spans developing subscription-based applications, migrating legacy codebases to modern SwiftUI, and ensuring UI reliability through unit and snapshot testing.
Having honed his craft at OZON.ru and now mentoring the next generation at Yandex Practicum, Chumikov brings a blend of technical rigor and user-centric design to his projects. At LifeQuest Hackathon, he served as a hands-on, insightful judge, demanding clean architecture, seamless interfaces, and robust logic—qualities that define his own work.
He pushed teams to justify their choices, polish their UIs, and test relentlessly. The results were nothing short of extraordinary.
First Place: Zenventures by Team Zen
Zenventures was more than an app—it was a mindset brought to life through code. Crafted by Team Zen, this gamified habit platform transformed daily routines into a role-playing saga. Users earned XP by completing habits in three pillars—mindful, Productive, and Fit—advancing through levels like characters in an epic game.
Unlike shallow gamification with mere badges, Zenventures dug deeper. It rewarded habit chains—linked actions like waking early → exercising → healthy breakfast—with bonus XP.
// Reward bonus XP for completing habit chains
const BASE_XP = 100;
const CHAIN_MULTIPLIER = 1.25;
/**
* Calculates bonus XP for habit chains with streak bonus.
* @param {Array<{completed: boolean}>} habitChain - Habits in chain.
* @param {number} streakDays - Current streak length.
* @returns {number} Bonus XP.
*/
function calculateChainBonus(habitChain, streakDays) {
if (!Array.isArray(habitChain) || habitChain.length === 0) {
console.warn('Invalid habit chain');
return 0;
}
const allCompleted = habitChain.every(h => h.completed);
if (!allCompleted) return 0;
let bonus = BASE_XP * habitChain.length * CHAIN_MULTIPLIER;
if (streakDays > 3) bonus *= 1.1; // Streak bonus
return Math.round(bonus);
}
This approach revealed a keen grasp of behavioral reinforcement, focusing on how interconnected habits foster lasting routines.
The team leveraged Google’s Gemini API to deliver adaptive quests and motivational prompts that were dynamically tailored to users’ streaks and mood inputs.
“AI-driven prompts are everywhere, but Zenventures’ reactive feedback feels like a well-crafted iOS app—intuitive and responsive, with a UI that invites engagement,” Chumikov noted.
Built with Next.js, Tailwind CSS, and DaisyUI, their frontend was sleek, responsive, and visually cohesive across devices. Subtle animations and tight feedback loops created an immersive experience.
Zenventures clinched first for its technical prowess and harmonious blend of design, psychology, and engineering—a digital world users wanted to inhabit.
Second Place: Rewardify by Team ForCoders
Rewardify took a grounded approach, prioritizing tangible incentives over fantasy. Users set personal rewards—like a coffee break, gaming session, or movie night—tied to XP milestones.
Their tech stack was formidable: Python 3.11, FastAPI, PostgreSQL, and SQLAlchemy formed a robust backend with modular reward logic.
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import validates
from .base import Base
class RewardTier(Base):
__tablename__ = 'reward_tiers'
id = Column(Integer, primary_key=True)
name = Column(String, nullable=False)
xp_required = Column(Integer, nullable=False)
reward_description = Column(String)
@validates('xp_required')
def validate_xp(self, key, value):
if value < 0:
raise ValueError('XP required must be non-negative')
return value
def is_unlocked(self, user_xp):
"""Check if user has enough XP to unlock this tier."""
return user_xp >= self.xp_required
Pydantic models ensured data validation, Alembic handled migrations, and rate-limited XP accrual prevented gaming the system.
The UI, styled with Tailwind and HTMX, was clean and distraction-free, delivering a fluid reward-tracking experience.
“Rewardify’s backend is as reliable as a well-tested iOS module. Its modular design and validation logic make it production-ready,” Chumikov remarked.
The team’s discipline shone through: meticulous commit messages, a pristine Docker setup, and a functional CI/CD pipeline via GitHub Actions.
Rewardify was a tool ready for real-world use—polished, practical, and brimming with potential.
Third Place: Wei by Ibrohim Abdivokhidov
Solo developer Ibrohim Abdivokhidov delivered something unique: emotional simplicity.
Wei wasn’t a complex dashboard but a conversational companion. This lightweight app offered daily prompts, celebrated consistency, and gently guided users through setbacks.
Built in TypeScript, Wei’s dialog engine adapted prompts based on user streaks and emotional tone.
interface User { streak: number; tone: 'positive' | 'neutral' | 'low'; }
interface Prompt { text: string; weight: number; }
/**
* Generates adaptive prompts based on user streak and tone.
* @param user - User data with streak and tone.
* @param promptOptions - Array to collect prompts.
*/
function generatePrompts(user: User, promptOptions: Prompt[]): void {
if (user.streak > 7) {
promptOptions.push({ text: 'Want to set a weekly milestone?', weight: 1 });
}
if (user.tone === 'low') {
promptOptions.push({ text: 'Tough day? Try a small step.', weight: 2 });
} else if (user.tone === 'positive') {
promptOptions.push({ text: 'Great vibe! Add a new goal?', weight: 1 });
}
if (user.streak > 0) {
promptOptions.push({ text: `Keep your ${user.streak}-day streak!`, weight: 1 });
}
}
Wei employed progressive disclosure, revealing more features as users engaged over time.
“Wei’s minimalism is its strength, like a SwiftUI app with a single source of truth. Its microcopy and adaptive prompts create a ” alive UI,” Chumikov said.
Technically lean, Wei used vanilla TypeScript and a swift Vercel backend. Its warm, non-judgmental microcopy made users feel understood.
Wei didn’t just build habits—it built connection.
Honorable Mentions & Breakthroughs
- Sanjay’s LifeQuest RPG: This productivity tracker synced with a Muse 2 headband detects focus lapses and triggers nudges, gamifying habits like a role-playing game.
- HabitQuest’s HabitQuest: A cross-device Pomodoro scheduler with multi-user co-working and lo-fi music tailored to tasks.
- Verve’s Catalyst: An AI-driven journaling tool recommending activities based on users’ mental and physical states.
These teams delivered exceptional polish: live deployments, robust databases, clear documentation, and pristine git histories.
Igor Chumikov’s Review of Philosophy
The hackathon’s distinction lay not only in its entries but in the caliber of its feedback.
Chumikov judged with an iOS developer’s meticulousness and a mentor’s wisdom. One review flagged a clunky state management approach, offering a SwiftUI-inspired solution:
import SwiftUI
import Combine
class HabitViewModel: ObservableObject {
@Published var habits: [Habit] = []
@Published var streak: Int = 0
private var cancellables = Set<AnyCancellable>()
init() {
// Subscribe to habit updates
$habits
.sink { [weak self] habits in
self?.updateStreak(habits)
}
.store(in: &cancellables)
}
func addHabit(_ habit: Habit) {
habits.append(habit)
}
private func updateStreak(_ habits: [Habit]) {
streak = habits.filter { $0.isCompleted }.count
}
}
struct Habit: Identifiable {
let id = UUID()
let name: String
var isCompleted: Bool
}
// Usage
struct HabitView: View {
@StateObject private var viewModel = HabitViewModel()
var body: some View {
List(viewModel.habits) { habit in
Text(habit.name)
}
}
}
He championed:
- Clean MVVM architecture over tangled logic
- Snapshot testing for UI consistency
- Fluid iOS-like user interactions over static designs
His feedback went beyond code:
“Your app works, but does it delight the user when they’re struggling to stay consistent? Think like an iOS designer.”
Teams left with refined code and a sharper vision for user-focused development.
A Remarkable Hackathon, Start to Finish
Every submission was:
- Deployed and live
- Demoed flawlessly
- Backed by passing tests
- Accompanied by thorough READMEs and guides
No filler. No unfinished experiments. Just systems built to ship or scale.
This was by design. LifeQuest prioritized craftsmanship over haste, and judging valued intent over hype.
“You weren’t just chasing a prize,” one participant shared. “You wanted your code to earn a nod from the judges.”
That’s the standard they met.
Final Reflections
The LifeQuest Balance Hackathon 2025 was more than a contest—it was a showcase of purposeful engineering. It celebrated asking deeper questions, writing elegant code, and creating tools for genuine human growth.
AI was molded to serve users, not dazzle them. Gamification fostered commitment, not obsession. The code was crafted for deployment, not just display.
If this is the future of development, it’s a future worth building toward.
Author’s note: This article is part of Hackathon Raptors’ series on technical mastery and project critique. All technical details are drawn from the official 2025 LifeQuest Balance Hackathon results.
