satya//7YA

worked a lot on paradox over time but completely forgot to log it properly earlier, ended up jumping to another project in between so logging this as a combined final entry.

spent a major portion of time improving the backend logic and overall data processing pipeline. refined how the analysis engine evaluates domains, especially the rating system. earlier it was more static and rough, but now it feels more balanced and meaningful based on multiple factors like security signals, response behavior and extracted metadata.

Backend Improvements

• improved the rating system to be more consistent and realistic
• refined how tls/ssl, domain reputation and server data are processed
• optimized api handling and response structure for better frontend integration
• reduced redundant processing and cleaned up internal logic

also revisited some older parts of the system from when the core features were first built and fixed inconsistencies in how different metrics were being calculated and displayed.

UI & Experience Updates

• made small but noticeable improvements to the ui for better clarity
• adjusted layout and spacing in the results page
• improved readability of complex data blocks
• refined some components to make the overall flow smoother

this wasn’t a full redesign but more of a polish pass to make the interface feel more stable and less cluttered.

Stability & Cleanup

• fixed edge cases where data would not load properly
• improved error handling and fallback states
• cleaned up parts of the codebase for better maintainability
• reduced unnecessary re-renders and improved performance in some areas

overall this phase was more about refining and stabilizing the project rather than adding flashy new features. paradox now feels more complete, with a better backend foundation and a cleaner user experience.

also yeah this is probably my final devlog for flavortown :)

Rebuilt and refined a major part of the project with a strong focus on the interface and overall user experience. shifted the entire UI to a clean light theme with improved visual hierarchy, making the analysis output more readable and better structured.

UI & Experience Improvements

• redesigned the molecular structure panel, structural composition grid, and estimated properties section
• improved data layout so information feels organized instead of just rendered
• enhanced spacing, typography balance, and component alignment
• updated buttons and input elements for a more minimal and modern feel

Frontend & Data Handling

• refactored frontend logic to better align with backend responses
• improved how molecular data is parsed and mapped into components
• made rendering more predictable and easier to scale for future features
• resolved inconsistencies in how chemical attributes were displayed

Responsiveness & Polish

• optimized layout for smaller screens to maintain clarity
• improved interaction flow for a smoother experience
• fine-tuned UI details to achieve a more cohesive look and feel

Integration & Final Touches

• revisited backend integration from the groq api rebuild phase
• ensured smoother data flow between backend and the new UI

overall, this update focused less on adding new features and more on refining the system into something cleaner, more usable, and closer to a complete product rather than just an experiment.

Heheheheh :) It’s done! 🎉 Version 1.0.0 is live! Just wrapped up the final major features:

New Commands Added:

• education - Shows academic background
• contact - Displays email and phone
• socials - Lists all social media links
• ls - Lists available portfolio sections (like Unix ls!)
• cat - Shows raw JSON data for any section

Technical Improvements:

• Added useMemo for prompt label optimization
• Created reusable get_json_section helper function
• Better error handling for invalid commands
• More comprehensive help system
• Added commented-out terminal header (for future UI upgrade)

Code Quality:

• Better TypeScript typing throughout
• More consistent command parsing
• Improved data structure organization
• Cleaner separation of concerns

The terminal now feels like a complete portfolio system! You can navigate through all aspects of my professional profile using familiar Unix commands. The cat command is especially cool - it shows the raw JSON data, which is great for debugging and transparency.

Added two of the most important commands: projects and experience!

The projects command now displays all my projects with:

• Project title and number
• Description
• Tech stack used
• Links to live demos/code

The experience command shows work history with:

• Role, company, and time period
• Detailed description of responsibilities
• Clean separator between positions
  I spent a lot of time on the formatting - wanted it to feel like reading a well-organized terminal output. The multi-line formatting for each project/experience entry makes it super readable.

Also added:

• More comprehensive help command
• Better data structure for projects and experience
• Improved error handling for missing data

The terminal is really starting to feel like a proper portfolio viewer now! Thinking about adding education section next, and maybe some JSON export functionality. The core architecture is handling the complexity really well

Just implemented dynamic data loading from a JSON file. The terminal now actually displays real portfolio information instead of hardcoded text!

Key improvements:

• Added async data loading with proper error handling
• Created TypeScript interfaces for portfolio data structure
• Added summary and skills commands that display actual content
• Implemented loading states with user feedback
• Better error messages when data fails to load
• The architecture is really coming together. Having the data in JSON makes it super easy to update without touching the code. The type safety is giving me confidence that the data structure is solid.

Next steps: I want to add projects and experience sections, but first I need to expand the data structure. Also thinking about adding some visual improvements like a terminal header with window controls. The foundation is rock solid now!

Just got the basic terminal interface up and running! Started with the foundation - a clean terminal that responds to basic Unix commands. Right now it supports help, about, date, whoami, pwd, and clear.

The terminal styling is minimal but functional - went with a dark theme because duh, terminals should be dark! The input handling is working smoothly, and I’m pretty happy with how the command parsing turned out.

Next up: I need to add the actual portfolio data and make it display dynamically. Thinking of loading it from a JSON file so it’s easy to update. The architecture is solid, just need to add the meat!

soo yeahhh just started working on this terminal style portfolio project. first thing i did was set up a fresh project using npm with vite latest, kept it simple and clean. removed all the default css and unnecessary stuff so i can build everything from scratch the way i want.

goal is to make it feel like a real terminal where everything works through commands and text, so starting with a clean base felt important. still early stage but setup is done and ready to build on top of it…

soo yeahhh been working on this project called paradox and honestly it turned out pretty cool lol. the whole idea was to build like a web analysis tool where you just drop a url and it tells you everything about it like security, performance, tls ssl stuff and overall domain health with ratings and all that.

started off simple, first made the basic landing page ui and just tried to get the vibe right. then moved to the results page and made it cleaner and more readable, connected the api and did a lot of small css tweaks here and there to make it feel smooth. it was messy at first ngl but after tweaking it again and again it started looking way better.

then did a big shift and migrated the whole ui to react which made things way more modular and easier to manage. after that set up deployment on vercel so updates are live instantly which is kinda satisfying lol.

also spent time fixing bugs like when results fail to load it now actually shows proper error instead of breaking the whole thing. reduced unnecessary re renders and cleaned up the code so it feels faster and more structured.

added a feature to show how many pages a site has and also count urls and js files linked which is actually pretty useful. overall the goal was to make complex web data feel simple and readable and i think it kinda does that now.

still a lot i can improve but yeahhh pretty happy with how it turned out so far

The first thing I focused on was improving the table design. It was functional before, but honestly it looked a bit dull. So I reworked it to feel cleaner and easier on the eyes — adjusted spacing, fixed alignment, and added a few subtle visual improvements. Nothing over-the-top, just enough to make browsing data feel smoother and less tiring.

After that, I shifted into more of an iterative phase — less about one big change and more about continuously building on top of what was already there. The goal was simple: make the app feel more alive and engaging, not just something that gets the job done.

Then I started thinking about how plain text isn’t always the best way to explain things. For topics like history, processes, flows, or hierarchical ideas, visuals just make more sense. So I built a system that can generate flowcharts or diagram-like structures whenever the question calls for it. Instead of forcing everything into paragraphs, the app can now switch to a more visual explanation when needed.

To make that work, I used a graph-based approach with React Flow. Setting it up wasn’t exactly straightforward — managing nodes, edges, and layouts took some effort — but once it clicked, the results were really solid. The explanations feel much clearer and more intuitive compared to just reading blocks of text.

Next, I tackled another problem: understanding. Just because someone reads something doesn’t mean they actually get it. So I added a small testing feature. For each question, the app generates a few quick follow-up questions — kind of like a mini quiz. It’s a simple addition, but it changes the experience from passive reading to something more interactive and self-checking.

I also spent some time making sure everything works properly in dark mode. Earlier, a few elements didn’t look quite right, especially graphs and UI components. I refined those so now both light and dark themes feel consistent and polished.

Along the way, I improved the sources system to make it smoother and more reliable. I also revisited the model settings, tweaking things slightly to make the overall behavior more usable and predictable.

Recently, I’ve started experimenting with something more ambitious — an Obsidian-style canvas. It’s still a work in progress, but the idea is to let users create notes, connect them, and maybe build their own small knowledge graph. Not fully there yet, just exploring how it fits into the app.

Overall, this phase wasn’t about a single standout feature. It was more about constant iteration — building, refining, experimenting, fixing, and repeating. A bit chaotic at times, but easily the most enjoyable part of the process.

Once the core system was working, I shifted focus to making the app feel more complete and polished. This phase was mainly about improving usability and adding depth.

I started by upgrading rendering. I added proper LaTeX support so math expressions display cleanly, and also improved code rendering so code blocks look neat and readable. This made the app much more flexible for both technical and general use.

Then I worked on improving response quality. I refined prompts, adjusted how messages are structured, and tuned the model behavior to get more consistent and useful outputs instead of random ones.

After that, I went back to the UI and improved the sidebar. I made it collapsible for better space control and added a small time and date display at the top. It is a simple detail but makes the interface feel more practical.

While working with sources, I noticed that content from the Jina API could sometimes fail. To handle that, I added a one-click remove option so users can quickly clean up broken entries.

I also added more customization. Users can now choose which model they want to use, and I included font settings so they can adjust how text looks based on their preference.

Another useful feature was allowing custom links and text as context. This lets users bring their own data into the system, making it more flexible for different workflows.

Finally, I implemented a proper light and dark theme system and made sure both look consistent and clean.

Overall, this phase was about refining everything. Small improvements, fixes, and additions that together made the app feel smoother and much better to use.

After the search and context flow, I kept pushing on improving the core experience, mainly around how content is handled and displayed.

I started with full markdown support across the app. Instead of showing plain text, everything is now properly formatted, which makes notes and extracted content feel much more structured and readable.

Then I focused on typography and overall presentation. With some help from the Gemini model, I worked on designing a custom text system, defining how headings, spacing, and content should look. The aim was to make reading feel smooth and natural, not just correct.

Once that felt stable, I moved to the backend side. I integrated the Gemma model and set up a clear API structure so inputs and outputs stay consistent. I made sure the flow from user input to response generation is clean and reliable.

After that, I designed the layout around this system. I added a sidebar that shows all active sources, so users can easily see where the information is coming from.

Finally, I implemented file chunking. Uploaded files are split into smaller parts and processed step by step, which helps in handling large data and sets up the system for future improvements.

Overall, this phase was about strengthening the foundation. Everything from rendering to AI integration now feels more connected and stable.

After working on the sidebar and making it feel more structured and interactive, I decided to push it a bit further by adding something more functional instead of just visual improvements.

So what I did next was introduce a “search context” button directly inside the sidebar. The idea behind this was to make it easier for users to actually find useful content like notes, articles, blogs, or anything relevant without leaving the app.

To make this work, I built a backend API for it. Instead of relying on just one source, I experimented with combining results from multiple search providers. I used Exa for more context-aware results and also integrated Brave Search API, then merged both responses together to get more meaningful and diverse outputs. This part was interesting because I had to think about how to normalize and combine the data so it actually feels useful instead of messy.

Once the search results were coming in properly, I connected it back to the UI and turned it into a proper feature. Users can now search for content directly from the sidebar and explore different sources in one place.

Then I added a simple “Add” button for each result so users can select what they want to include. The goal here was to make the flow feel smooth, like you search, pick what you need, and move forward without friction.

After that, I went a step deeper and worked on extracting actual content from the selected sources. Using Jina API, I wrote logic to retrieve the markdown content from the selected websites. So instead of just showing links, the system can actually pull in structured content that can be used inside the app itself.

Overall, this turned out to be more than just a small feature. It started as a simple idea but ended up becoming a full flow where users can search, select, and import useful context into their workspace. It definitely made the project feel more practical and closer to something people can genuinely use for studying or research.

Just deployed my latest project 🚀

It’s a minimal AI-powered study tool built to make learning a bit more interactive and less boring. You can explore notes, generate quizzes, and experiment with different ways of studying — all in one place.

⚠️ Note: Please don’t misuse the API keys. If you want, feel free to use your own keys while testing.

I’m still working on polishing things (UI tweaks, tracker improvements, etc.), but it’s in a usable state now.

Would really appreciate it if you try it out and share your feedback 🙌

Meanwhile, I’m off watching my favorite anime 😄

Finally after all of this, I moved into a phase where I just kept building on top of everything and trying to make the app feel more alive and actually fun to use, not just useful.

So first thing I did was improve the tables design. Earlier it was working but it felt kinda plain and boring, so I redesigned it a bit to make it cleaner and more readable. Spacing, alignment, small small visual tweaks, all that stuff. Nothing too flashy but enough to make it feel nicer when you actually look at data.

Then I started thinking about something more interesting. Like whenever a user asks something where a normal text answer is not enough, for example history, flows, step by step processes, tree structures or anything like that, it would actually be better if we could show it visually. So I added a flowchart / diagram type system. Basically if the question feels like it needs a visual explanation, the app can generate a graph-style diagram.

For that I used graph-based rendering and integrated React Flow. Setting that up was a bit tricky ngl, handling nodes, edges, layout and all, but once it started working it looked really good. It makes explanations feel way more clear compared to just paragraphs.

After that I thought okay reading is fine but how do we know if the user is actually understanding anything. So I added a quick test feature. For every question, there are like 4 small questions generated. These act like a mini test so the user can check if they actually understood what they just read. It is simple but kinda powerful because it turns passive reading into something a bit interactive.

Then I also made sure all of this works properly in dark mode. Graphs, tests, UI elements, everything. Earlier some parts looked off in dark theme so I refined that as well. Now both light and dark feel consistent.

I also updated the sources system a bit more to make it smoother and more reliable. And yeah I went back again to model settings and improved it slightly, tweaking how things behave and making it a bit more usable overall.

And one more thing I have started experimenting with is something like an Obsidian-style canvas. Still in progress but the idea is that users can create their own notes, connect them, maybe build a small knowledge graph kind of thing. Not fully done yet but trying it out and seeing how it fits into the system.

So yeah this part was less about one big feature and more like continuous building, improving, trying new ideas, fixing things, adding small details again and again. Kinda messy process but also the most fun part honestly.

After building out the core system and getting the main flow working, I shifted my focus toward making the experience more complete and polished. This phase was all about adding depth, improving usability, and fixing the small things that actually matter a lot in real usage.

I started by expanding the rendering capabilities even further. I added proper LaTeX rendering so mathematical expressions can be displayed cleanly, which is especially useful for study-related content. Along with that, I also implemented code rendering, making sure code blocks are formatted nicely and remain readable. This made the platform much more versatile because now it can handle technical, academic, and general content all in one place.

After that, I spent time polishing the overall system. One thing I noticed was that the model responses were not always as good as I wanted. So I worked on improving that by refining how the models are used. I adjusted prompts, improved the message structure, and did some level of fine-tuning to get better and more consistent outputs. I also focused on optimizing response behavior so the answers feel more useful and less random.

Then I moved back to the UI and started enhancing the sidebar again. I made it collapsible so users can choose when they want more space versus when they want quick access to tools. On top of that, I added a small but useful feature showing the current time and date at the top of the sidebar. It is a simple addition, but it makes the interface feel more alive and practical.

While working with sources, I ran into an issue where sometimes content fetched through the Jina API would fail or not load properly. Instead of leaving users stuck with broken entries, I added a one-click remove option so they can easily clean up their sources. This made the system feel more controlled and user-friendly.

To give users more flexibility, I added a model settings option where they can choose which model they want to use. This opens up more control depending on the type of task or response they expect. Along with that, I also introduced a font customization feature so users can change how the text looks based on their preference. Whether they like cleaner fonts or something more stylized, they can adjust it accordingly.

Another important addition was the ability to include custom links and text as context. This allows users to manually add their own sources and send them to the model, making the system more flexible and powerful for personalized workflows.

Finally, I implemented a proper theme toggle with well-designed dark and light modes. Instead of just switching colors, I made sure both themes feel consistent and visually appealing.

Overall, this stage was about turning the project from something that works into something that feels good to use. A lot of small improvements, fixes, and enhancements came together to create a much smoother and more complete experience.

After setting up the search and context flow, I continued working further on improving the core experience of the app, especially around how content is rendered and processed.

One of the first things I focused on was implementing full markdown rendering across the app. Instead of treating content as plain text, I made sure everything could be properly parsed and displayed with rich formatting. This made a huge difference because now notes, articles, and extracted content actually feel readable and structured rather than raw data.

After getting markdown working, I moved on to improving the overall typography and visual presentation. For this, I used the Gemini model to help guide how content should be structured and displayed. I ended up designing a fully custom typography system, thinking through how headings, paragraphs, spacing, and emphasis should look. The goal was to make reading feel smooth and intentional, not just technically correct.

Once the rendering and design side felt solid, I shifted focus to the backend intelligence. I integrated the Gemma model and set up its API properly. This involved defining a clear message structure so inputs and outputs stay consistent and predictable. I spent time making sure the flow between user input, processing, and response generation was clean and scalable.

After that, I worked on designing the complete page layout around this system. I built a sidebar that can display all the sources being used, so users can clearly see where their context is coming from. This helps make the experience more transparent and organized.

Finally, I implemented a chunking mechanism for handling files. Whenever files are uploaded, they are automatically split into smaller chunks and then processed step by step. This makes it easier to handle large inputs and also prepares the system for more advanced features later on.

Overall, this phase of development was less about adding one single feature and more about strengthening the foundation. From markdown rendering to AI integration and file processing, everything now feels more connected and closer to a complete system rather than separate parts.

After working on the sidebar and making it feel more structured and interactive, I decided to push it a bit further by adding something more functional instead of just visual improvements.

So what I did next was introduce a “search context” button directly inside the sidebar. The idea behind this was to make it easier for users to actually find useful content like notes, articles, blogs, or anything relevant without leaving the app.

To make this work, I built a backend API for it. Instead of relying on just one source, I experimented with combining results from multiple search providers. I used Exa for more context-aware results and also integrated Brave Search API, then merged both responses together to get more meaningful and diverse outputs. This part was interesting because I had to think about how to normalize and combine the data so it actually feels useful instead of messy.

Once the search results were coming in properly, I connected it back to the UI and turned it into a proper feature. Users can now search for content directly from the sidebar and explore different sources in one place.

Then I added a simple “Add” button for each result so users can select what they want to include. The goal here was to make the flow feel smooth, like you search, pick what you need, and move forward without friction.

After that, I went a step deeper and worked on extracting actual content from the selected sources. Using Jina API, I wrote logic to retrieve the markdown content from the selected websites. So instead of just showing links, the system can actually pull in structured content that can be used inside the app itself.

Overall, this turned out to be more than just a small feature. It started as a simple idea but ended up becoming a full flow where users can search, select, and import useful context into their workspace. It definitely made the project feel more practical and closer to something people can genuinely use for studying or research.

So today I spent a solid chunk of time refining the sidebar of my project. Initially, the goal was simple just make it clean and usable but as I got into it, I ended up pushing it much further to give it a more polished and professional feel overall.

I started by properly structuring the sidebar layout, making sure spacing, alignment, and hierarchy all felt intentional rather than just “placed there.” Once that base felt stable, I experimented with adding drag-and-drop functionality. That part was actually pretty fun to work on — getting elements to move smoothly and behave predictably took some tweaking, but it definitely made the sidebar feel more interactive and dynamic instead of static.

After that, I added a theme toggling option at the bottom of the sidebar. I wanted it to feel like a complete experience rather than just a UI component, so giving users control over themes felt like an important touch. It also helped me think more about consistency in design — making sure both light and dark modes looked equally clean.

Overall, the main intention throughout was to move away from something that looks “just functional” to something that feels thoughtfully designed and slightly more production-ready.

Apart from the UI work, I also explored how indexing should work in the project. I added options to control how files are split into chunks — like how many chunks should be created and how the data is processed. Honestly, I’m not 100% sure yet if I’ll end up using this feature in the final version, but I still went ahead and implemented the option anyway. I figured it’s better to have that flexibility early on rather than regret not designing for it later.

So yeah, this update was a mix of UI refinement, interactivity improvements, and a bit of forward-thinking experimentation. Not everything I built today might make it into the final product, but it definitely helped me understand the system better and push the project a step closer to something more complete.

fixed the api problems and image loading things.. and optimized it for mobile devices a Lil bit

completely rebuilt the system using the groq api, which now handles all backend logic and data processing. i overhauled the entire website structure and UI for a cleaner look, rewrote the epoxy code into javascript from scratch to improve the core logic and finally deployed the live version on vercel.

Resolved several bugs related to chemical parsing and optimized the logic for reading chemical formulas. Also updated the design of the Node HTTP server page for better readability.

enhanced the ui by integrating a header image for improved chemical structure visualization… refined the overall layout and optimized additional system parameters.. :)

experimented with building a lightweight cheminformatics engine in my hybrid language, Epoxy. implemented a basic parser to analyze chemical formulas and compute structural details, then designed a simple server rendered tailwindcss + html interface through epoxy’s best feature javascript interpolation to present the output in a structured format…

Improved the overall design and refined the UI for a cleaner look. Fixed several bugs, including handling cases where result fetching fails.. it now properly shows an error instead of breaking. Reduced unnecessary re-rendering to improve performance and optimized parts of the codebase for better structure and readability. Also added a new feature that lets users see how many pages the website has and how many URLs and JavaScript files are linked to it.

successfully migrated the entire sites ui to react, moving to a more modular component based architecture for code maintenance … after finalizing the code, i pushed the latest version to github and configured an automated deployment pipeline via vercel for seamless live updates :)

designed the search results page with a much cleaner look :) integrated the api to make everything functional, then made some manual css adjustments here and there to improve the overall ui.. had to tweak a few things, but it was totally worth it…its looking much better now.

made the basic landing page ui of the website ::))

made this website, generated all the images for each status code, designed the background, wrote the code, and finally deployed the website :)

finally finished this project :)
polished the ui.. added some background patterns and wrote the function to set the colours to red or green for chosen options based on right or wrong.. and also added the full breed array.. its done :) themksuuuuuu

designed the ui of the homepage and the background of the website… and added the full list of dog breeds

last day i wrote the basic functioning of the website like the random options generator and answer checking function.. and also implemented the dogs breed api for random dog images.. now i will make an array list of dogs breed for the options also..