The client asks.
The browser never decides what it is allowed to modify. It only requests an operation through the application layer.
A technical deep dive into how Hack The Future is engineered — from the first interaction on a student's phone to React rendering, server functions, authentication, database security, AI systems, browser-based Python, offline storage and production infrastructure.
Hack The Future has been built as a complete technology ecosystem from the ground up. The current focus is on building the product, validating the experience and bringing the ecosystem to students.
AI-powered career and skill-development ecosystem.
Early-stage and recently started.
Current revenue generated: ₹0.
Approximately ₹2.50 lakh invested in development.
Hack The Future does not treat the browser as a trusted environment. Client interfaces request operations, while authentication, validation, authorization and sensitive database mutations happen through the server architecture.
A student clicks a button, submits a form, completes a challenge or requests AI assistance.
onSubmit()
The React component collects the required values and invokes the corresponding server function.
function()
The operation enters a server-only createServerFn function.
createServerFn()
Input is validated before the server performs any trusted operation.
Zod.parse()
Protected requests carry the authenticated user's bearer token.
user.id
PostgreSQL Row Level Security determines which records the authenticated user can access.
policy()
The database performs the permitted operation and returns the result to the server.
SELECT / INSERT / UPDATE
The server returns only the data required by the application. Sensitive credentials and protected database information never become part of the browser bundle.
The browser never decides what it is allowed to modify. It only requests an operation through the application layer.
Server functions validate incoming parameters before they reach business logic or the database.
Authentication middleware attaches the authenticated identity to protected operations.
PostgreSQL policies determine whether that particular user can read or modify the requested record.
Rewards, grades, achievements, wallet operations and coupon redemption use server-authoritative operations.
The browser receives the application result instead of receiving database credentials, AI provider secrets or other private infrastructure information.
The question system is designed around a shared problem bank. Questions can be generated on demand for practice, while the hardest-tier daily and weekly challenges can be regenerated automatically by the backend.
The learner selects the desired topic, difficulty and problem style.
The browser calls a protected server-side generation function.
The backend converts the request into a structured generation instruction.
The server-side AI gateway sends the generation request to the configured model.
The generated result is converted into the platform's expected problem structure.
The generated problem is stored in the shared question repository.
Student opens a generated or curated challenge.
Code is written directly inside the browser.
The submitted solution is executed against the configured evaluation process.
Test cases determine whether the solution produces the expected output.
The learner receives the execution result and can iterate on the solution.
A scheduled backend process can regenerate the hardest-tier challenge on a weekly cycle. The scheduled process calls a signed public endpoint, which triggers the protected generation workflow.
Challenge completion is recorded through trusted server routines. This means the browser can report an attempted completion, but valuable reward state is controlled by backend logic rather than arbitrary client-side values.
OTP authentication is deliberately server-controlled. The browser requests an OTP, but the valid OTP itself is never exposed to the browser. Generation, hashing, storage and verification happen on the trusted side.
The student enters an email address and requests a one-time login code.
email@example.com
The request enters the authentication backend. The browser does not generate the trusted OTP.
createServerFn()
A one-time verification value is generated on the server.
RANDOM OTP
The server stores a hash rather than exposing the valid OTP to the client.
OTP → HASH
The email is delivered through the authorised Gmail infrastructure and the platform's email template.
GMAIL API
The authenticated session becomes available to the application and the user's profile can be created or loaded.
The server rejects the verification attempt rather than allowing the client to decide whether the OTP is valid.
AI credentials, Gmail credentials, webhook secrets and other private infrastructure values are also read inside server handlers and never exposed to the browser bundle.
Every protected operation is evaluated against the authenticated user's permissions and the database policies.
The interface is only the beginning. A typical protected operation moves through the application layer, server functions, validation, authentication and database security before the response reaches the user again.
Server-side AI handles tutoring, career analysis, resume processing, roadmaps and coaching.
Python executes inside a browser Web Worker without blocking the main interface.
Lessons and Sparks use controlled video playback through the YouTube IFrame API.
Server-side execution and rendering can happen close to the user at the edge.
The architecture combines a modern React application, edge execution, a relational data layer, server-side AI, browser computation and progressive-web-app capabilities.
Each major module solves a different part of the learner's journey while sharing the same underlying authentication, data, AI and application infrastructure.
The career layer combines profile data, resume analysis, company matching, role-based roadmaps and AI coaching to help users understand possible career directions.
A coding practice environment containing curated problems, browser-based editing, test execution and locally cached practice content.
A Jupyter-style browser notebook where Python code executes through Pyodide inside a Web Worker. Scientific libraries can be used without blocking the main interface.
Course catalog, video lessons, quizzes, progress tracking, analytics, calendar and attendance work together as the learning layer.
A vertical short-video experience for bite-sized learning and discovery, powered by YouTube playback and local state.
Users can submit application information, skills, target roles and resumes. AI can assist with extracting relevant information from uploaded resumes.
Daily and weekly challenges create a structured mechanism for continuous practice and progress.
XP, Sparks, streaks, levels, achievements and leaderboards create a visible progression system around learning activity.
Mentorship pathways connect the learning ecosystem with guidance and career development.
AI is not treated as the entire product. It is integrated where reasoning, personalization, analysis or generation can improve the learner's workflow.
The learner writes code inside a notebook cell.
Execution moves away from the main UI thread.
Python executes directly in the browser runtime.
Scientific packages can be loaded for analysis.
Text, tables and visualizations return to the notebook.
Notebook state can remain available locally.
Sensitive operations are deliberately kept away from the client. Validation, authentication and database policies form the trust boundary.
The architecture is designed around the principle that the complete experience should remain usable on an affordable Android phone, including when internet connectivity becomes unreliable.
Hack The Future is currently at an early stage. The focus has been on building the underlying product and technology rather than presenting artificial traction or revenue numbers.
Application architecture, frontend, server functions, database integration, product modules and system integration.
AI integration, notebook architecture, server-side AI workflows and intelligent product experiences.
Hosting, database infrastructure, edge runtime, deployment and supporting production services.
Interface architecture, responsive experience, interaction design and product-level visual systems.
Device testing, performance refinement, debugging and iterative product improvements.
Initial operational setup, deployment preparation and launch-related technical work.
The project has just started and currently reports ₹0 in revenue. The ₹2.50 lakh figure represents development investment, not money earned. The objective at this stage is product development, validation and establishing the foundation for future monetization.
I am Vansh Raj Singh, professionally known as Vansh Rajput, an Indian GenAI Developer, technology entrepreneur, content creator and digital educator.
I completed my Bachelor of Computer Applications (BCA) from Integral University, Lucknow, and I am currently pursuing a Master of Computer Applications (MCA) in Artificial Intelligence & Machine Learning with SAS at Chandigarh University, Uttar Pradesh.
I am the Founder & CEO of Hack The Future, a gamified skill development, internship and career ecosystem dedicated to helping students across India learn in-demand skills, gain practical experience and transform their knowledge into real income opportunities.
My work focuses on generative AI, full-stack development, educational technology and building innovative digital products that make learning more practical, accessible and impactful for the next generation.
Built from the ground up to connect learning, practice, projects, consistency and career opportunities in one ecosystem.
Explore Hack The Future