Hey everyone! I’m back with another update on my quiz web application journey. 🚀 If you've been following along, you know the goal is to build a platform that helps students prepare for their interviews. What started as an experiment with AI-generated questions has now taken a new direction, and I’m here to share the reasons, the challenges I’ve faced, and the progress so far. Let’s dive in!

Initial Objective: AI-Generated Questions for the Quiz App

Originally, my idea was to use AI services to generate quiz questions dynamically, thinking it would save time and offer a wide variety of content. I experimented with various APIs like OpenAI, Hugging Face, and Groq. Sounds futuristic, right? But things didn’t go as smoothly as planned. 😅

Here’s what went wrong: its the controller class for open ai api

1.   Out of Credits: OpenAI gives $18 in free credits to early adopters. After that, it’s pay-to-use. I ran out of credits quicker than I anticipated. 💸package com.example.quizapp.Controller;
     import org.springframework.web.bind.annotation.RestController;
     import org.springframework.web.client.RestTemplate;
   
     import com.example.quizapp.DTO.chatGPTRequest;
     import com.example.quizapp.DTO.chatGPTResponse;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.beans.factory.annotation.Value;
     import org.springframework.http.HttpStatus;
     import org.springframework.http.ResponseEntity;
     import org.springframework.web.bind.annotation.GetMapping;
     import org.springframework.web.bind.annotation.RequestMapping;
     import org.springframework.web.bind.annotation.RequestParam;
   
     @RestController
     @RequestMapping("/question")
     public class QuestionControler {
   
         @Autowired
         private RestTemplate restTemplate;
   
         @Value(value = "${openai.api.url}")
         String apiURL;
         @Value(value = "${openai.model}")
         String model;
   
         @SuppressWarnings("null")
         @GetMapping("/allQuestions")
         public ResponseEntity<String> getAllQuestions(@RequestParam String topic, @RequestParam String level) {
             try {
                 String prompt = "Generate 10 " + topic + " quiz questions having " + level + " difficulty, each with 4 options and specify the correct option in JSON format. Each question should include the question text, an array of options, and the correct answer. The JSON format should look like this: { 'questions': [ { 'question': 'What is ...?', 'options': ['A', 'B', 'C', 'D'], 'correct_answer': 'A' } ] }";
                 chatGPTRequest request = new chatGPTRequest(model, prompt);
   
                 ResponseEntity<chatGPTResponse> response = restTemplate.postForEntity(apiURL, request, chatGPTResponse.class);
   
                 if (response.getBody() != null && !response.getBody().getChoices().isEmpty()) {
                     return ResponseEntity.ok(response.getBody().getChoices().get(0).getMessage().getContent());
                 } else {
                     return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Failed to generate questions: Empty response from OpenAI");
                 }
             } catch (Exception e) {
                 return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Failed to generate questions: " + e.getMessage());
             }
         }
     }
   

2. Unreliable Output Formats: The AI models, while great for chatbots, weren’t delivering quiz questions in a steady JSON format. Sometimes the response included extra text or string formats that weren’t directly usable. I tried tweaking the prompts, but the results were inconsistent.

package com.example.quizapp.Config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.SimpleClientHttpRequestFactory;

@Configuration 
public class OpenAIConfig {

    @Value("${openai.api.key}")
    private String openApiKey;

    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate(new SimpleClientHttpRequestFactory());

        ClientHttpRequestInterceptor interceptor = (request, body, execution) -> {
            request.getHeaders().add("Authorization", "Bearer " + openApiKey);
            request.getHeaders().add("Content-Type", "application/json");
            return execution.execute(request, body);
        };

        restTemplate.getInterceptors().add(interceptor);
        return restTemplate;
    }
}

Facing Reality: Two Options

At this point, I had two paths ahead:

1. Buy a subscription for a more reliable AI model. (Not ideal when you’re on a tight budget and learning in public. Plus, this was a side project meant to be free-to-use.)

2. Manually feed questions into the system by adding an admin functionality. This way, I’d have full control over the quality and structure of the quiz content.

As much as I loved the idea of AI doing the heavy lifting, I decided to switch to manual question input for now. It felt more realistic and manageable, especially with my self-imposed deadlines. But don’t worry—I’m not abandoning the AI option. I’ll definitely revisit it in the future. For now, I just need to get this project done!

Current Progress: Manual Question Input + Admin Controls

Since I decided to go with manual question/answer entry, I’ve focused on adding admin functionality to manage the questions directly. This gives me full control over the content and ensures everything is structured properly for users.

Here’s a quick overview of what I’ve done so far:

1. Admin Interface: I built an admin panel where questions can be added or updated manually.

2. Endpoints Created: Using Spring Boot and PostgreSQL, I created several API endpoints for both normal users (to fetch quiz questions) and admins (to add or modify questions).

3. User Interface: A basic front end is set up for users to take quizzes, with admin features accessible behind the scenes. It’s simple, but functional!

Here’s a sneak peek of the project so far:

What’s Next?

Even though I’ve shifted away from dynamic question generation for now, the learning has been immense. This challenge helped me get my hands dirty with:

• Working with Spring Boot for building robust APIs.

• Exploring PostgreSQL for database management.

• Learning about the balance between relying on external APIs and building your own solutions.

I’m still planning to come back to the AI part once this project is complete, but for now, my focus is on delivering a stable, working product.

If you’re curious to see my code (and where I struggled), feel free to check out my GitHub repo: https://github.com/utkarsh125msh
Follow me on X : https://x.com/6Meshram93984

Final Thoughts

This project is teaching me a lot, and I’m loving the challenge—even if things didn’t go as originally planned. At the end of the day, that’s what learning in public is all about: adapting, growing, and sharing the journey with others.

Stay tuned for more updates! Until then, keep exploring and building. 💻✨

Tags: #LearnInPublic #QuizApp #SpringBoot #PostgreSQL #BackendDevelopment #OpenAI

Hey there! 👋

Super excited to share something with you all—I'm diving into the world of learning in public and want you to be a part of it! I’ll be working on a fun project: a Quiz Web Application. But here’s the cool part—I’m not just building it behind the scenes. I’m sharing the whole process with you as I go! Yep, that means all the ups, downs, wins, and fails.

What’s This Project All About?

I’ll be building a Quiz Web Application where users can:

• for authentication and authorization (Log in 🛡️)

• Take quizzes with different difficulty levels 🎮

• Check out a leaderboard to see how they rank 🏆

• And many more as we move forward

I’ll be using some awesome tools for this project, like a SQL database, and Spring boot for backend api, React for frontend and bunch of cool web technologies. It’s all about learning, experimenting, and sharing the journey!

What I Already Know:

I’ve got a decent handle on Core Java and Spring Boot (since I’ve been more of a backend guy so far). But there’s still so much to learn! As I build this quiz web app, I’ll be sharpening my existing skills and tackling new ones along the way. Whether it’s frontend, design, or handling databases, I’ll figure it out as I go—and I’ll share all of that with you!

What You Can Expect:

Here’s what I’ll be doing:

• Building from scratch (so, you’ll see all the early-stage chaos)

• Posting about any challenges I face and how I get past them (bugs, errors, bad ideas, you name it)

• Sharing resources that help me along the way

• Dropping code updates on GitHub for you to follow along!

Here’s the schedule:

• Monday to Thursday: I’ll be working on the project and learning new stuff.

• Twitter: I’ll share quick updates, wins, and maybe a few frustrations.

• Hashnode: I’ll write more detailed posts about what I’ve learned and how I’ve solved problems.

• GitHub: The source code will live here for you to explore (or laugh at) as it evolves.

Come Join the Fun!

I’d love for you to tag along on this ride! Whether you're learning to code too, building your own project, or just curious about what this whole "learning in public" thing is about, you’re welcome to follow along!

• Twitter: Quick updates and real-time progress—Follow me here X

• Hashnode: For in-depth breakdowns and problem-solving—Read my blog ✍️

• GitHub: Want to check out the code? It’s all here—See the repo 💻

Why Am I Doing This?

I’m a big believer in learning in public. By sharing this journey, I hope to:

• Keep myself motivated 💪

• Help others by showing the real, messy process 🧠

• Connect with other learners and developers 🤝

It’s going to be a fun ride, full of trial and error, and I’m ready to dive in. Let’s see where it takes us!

Let’s Ride Together!

If you’re interested in coding, learning new things, or just want to see what happens, feel free to follow along! Hit me up with feedback, ideas, or just say hi—I’m always up for a chat. Let’s learn and grow together! 🚀