Skip to content
Prakash Builds
Prakash Builds · Next.js & Web Developer

Hey, I’m Prakash 👋
I build software & explore ideas.

I’m a Next.js and full-stack web developer based in India, working with people around the world. I build fast web apps with Next.js, React and AI, and share notes on dev tools and lessons learned along the way.

Daily Content
•
Tech Notes
•
Learning in Public
Prakash - Software Developer & Builder

Prakash

Creating & Sharing Daily

Creator

How Can
I Help You?

Master Web & Tech

Learn modern web development, Next.js, TypeScript, and clean architecture based on real building experience.

Get started

Learn AI & Dev Tools

Learn how to leverage AI tools, pair-programming workflows, and modern software tooling to build faster.

Get started

Be More Productive

Learn how to manage your time, structure developer workflows, and achieve your goals while enjoying the journey.

Get started
$

Build Products & Apps

Learn how to build and launch side projects, full-stack applications, and open-source tools for fun and impact.

Get started

... and more!

Explore all content
Focus & Interests

Currently Exploring

Exploring

AI-Assisted Development

Figuring out where AI genuinely speeds up building software, and where it just adds noise.

Learning

Next.js & the App Router

Going deep on server components, streaming, and the newer rendering model.

Learning

Modern Web Fundamentals

Revisiting the browser platform itself — performance, accessibility, and what's changed.

Experimenting

AI Coding Tools

Running the same feature through different AI-assisted workflows to see what actually holds up.

Exploring

Interface Design

Studying the small decisions — spacing, motion, type — that separate good UI from generic UI.

Experimenting

Developer Productivity

Testing workflows, editor setups, and habits that hold up over a full week, not just a demo.

My Digital Laboratory

Experiments

Not everything needs to become a product. Sometimes the best way to learn is to simply try something.

All experiments
ExploringEXP-01
Oct 4, 2026•Lab Spike

Building a Multi-Provider AI Chatbot with Free APIs

An experiment in building a website AI chatbot using Puter, Groq, and NVIDIA APIs with a multi-provider fallback system.

Key Finding

AI Chatbot with Multiple AI ProvidersA small experiment in adding an AI chatbot to my website using multiple AI providers instead of depending on a single API.The chatbot currently integrates Puter, Groq, and NVIDIA Build, with a fallback approach between the available providers.The goal was simple: build a useful AI chatbot while experimenting with different AI APIs and keeping the initial setup focused on free API access and provider redundancy.Project Status: Implemented and publishedAI Providers: Puter, Groq, NVIDIA BuildArchitecture: Multi-provider fallbackFocus: AI API experimentation and reliabilityThe AI ProvidersPuterPuter is used as one of the primary AI options in the chatbot.One of the interesting aspects of Puter is its approach to providing free AI access through Puter.js, making it useful for experimenting with AI features without immediately building a traditional paid API setup.For this project, Puter provides one of the available routes for processing chatbot requests.GroqGroq is another provider integrated into the chatbot.One of the reasons I wanted to experiment with Groq was its fast inference performance and access to different AI models.The free API access is subject to Groq's own usage limits, rate limits, and policies.This makes it useful not only as an AI provider but also as an opportunity to experiment with handling provider-specific limitations.NVIDIA BuildNVIDIA Build is also included as another AI provider.It provides access to NVIDIA-hosted AI models and gives the chatbot another option when working with multiple AI providers.Adding NVIDIA to the architecture also makes the experiment more interesting from an integration perspective because each provider can have different API behavior, authentication requirements, models, and limitations.The Fallback ArchitectureInstead of depending on a single AI provider, the chatbot is designed around a fallback architecture.The basic flow is:User ↓ AI Chatbot ↓ Provider 1 ↓ If unavailable ↓ Provider 2 ↓ If unavailable ↓ Provider 3 ↓ Return Response The idea is straightforward:Try the preferred provider first. If it fails or is unavailable, move to the next provider.This gives the chatbot multiple options for handling AI requests instead of allowing a single provider failure to completely stop the chatbot.Why Use Multiple AI Providers?Using multiple providers makes the experiment more interesting and provides several practical advantages.Provider RedundancyIf one provider is temporarily unavailable, rate-limited, or experiencing an API issue, another provider can potentially handle the request.Model ExperimentationDifferent providers offer access to different models and AI capabilities.Having multiple integrations makes it easier to experiment with different models and compare their behavior.Performance DifferencesAI providers can have different inference speeds, response times, and infrastructure characteristics.Using multiple providers provides an opportunity to experiment with those differences in a real application.Lower Initial CostFree API access makes it easier to experiment with AI functionality without immediately committing to paid infrastructure.Learning About Failure HandlingMultiple providers also introduce real-world engineering problems such as:API failuresRate limitsAuthentication errorsModel availabilityTimeoutsProvider-specific responsesNetwork failuresDifferent API formatsThese problems are an important part of building reliable AI applications.Free API AccessFor this experiment, I am using the free API access available from the providers.Puter is used with its free AI access model, while Groq and NVIDIA access remains subject to their respective provider limits, quotas, and policies.The purpose of the experiment is not to claim that every provider offers unlimited API usage.Instead, the goal is to explore how multiple free or limited-access AI services can be combined into a single chatbot architecture.The objective: Build and experiment first, while keeping the initial infrastructure cost as low as possible.Handling Provider FailuresOne of the more important parts of this experiment is handling what happens when an AI provider does not respond successfully.A chatbot that works only when everything goes perfectly is not particularly resilient.The application needs to consider situations such as:Provider unavailableAPI request failureRate limit reachedInvalid authenticationModel unavailableRequest timeoutTemporary service errorsInstead of immediately returning an error to the user, the fallback system can attempt to use another configured provider.This makes the provider layer an important part of the chatbot architecture rather than simply being an API wrapper.The Real ChallengeThe interesting part of building an AI chatbot is not simply connecting an API and sending a prompt.The real challenge starts when the application needs to work with multiple providers.Each provider can have different:API endpointsAuthentication methodsRequest formatsResponse structuresModelsRate limitsError formatsAvailability characteristicsBecause of this, the chatbot needs a layer that can manage those differences while presenting a consistent experience to the user.What I LearnedThis experiment reinforced an important lesson about AI application development:The AI API is only one part of the system.A production-ready chatbot also needs to think about reliability, error handling, provider abstraction, rate limits, authentication, model selection, and fallback behavior.The multi-provider architecture made it possible to experiment with these concepts in a practical application rather than testing each API independently.It also gave me a better understanding of how different AI providers can be combined behind a single user-facing interface.The ResultThe final chatbot currently includes:Puter integrationGroq integrationNVIDIA Build integrationMulti-provider fallbackAI model experimentationProvider failure handlingFree/limited API accessA single chatbot interfacePublic deploymentThe user does not need to know which provider is handling a particular request.The provider layer works behind the chatbot interface and gives the application multiple options for processing AI requests.What's Next?This is still an experiment, and there is plenty of room for improvement.Future iterations could explore:Smarter provider selectionModel-specific routingResponse-time-based provider selectionBetter retry strategiesProvider health checksUsage trackingRate-limit awarenessConversation memoryStreaming responsesMore AI providersBetter error reportingThe goal is to gradually evolve the chatbot from a simple API experiment into a more robust multi-provider AI architecture.Experiment StatusImplemented and PublishedThe chatbot is currently live and working with multiple AI providers.This experiment gave me hands-on experience with integrating different AI APIs, handling provider failures, and designing a fallback architecture that can continue evolving as I add more AI capabilities.

#Experiment
Read Notes
ExploringEXP-02
Oct 3, 2026•Lab Spike

Building a Fully Customized Headless CMS with Payload CMS

An experiment where I customized the open-source Payload CMS into a flexible headless CMS with dynamic collections, custom fields, users, and Cloudflare deployment.

Key Finding

Fully Customized Headless CMS Built on Payload CMSI wanted more control over my CMS.Instead of building a completely new CMS from scratch, I started with Payload CMS, an open-source headless CMS, and customized it around the way I wanted to manage content.The result is a fully customized headless CMS that combines the flexibility of Payload with a more visual and dynamic content-management experience inspired by platforms such as Webflow and Framer.Project Status: Completed and deployedFoundation: Payload CMSInfrastructure: CloudflareHosting Cost: $0 initial hosting costStarting With Payload CMSPayload provided the foundation for the project.Rather than reinventing authentication, collections, content management, and the underlying CMS architecture, I used the open-source Payload codebase as the starting point and built my own functionality on top of it.This allowed me to focus on the parts of the CMS that I actually wanted to change, customize, and extend.Dynamic CollectionsOne of the main features I added was a dynamic collection system.Instead of creating every content type manually in code, the CMS can be configured around dynamic collections and their fields.This makes it possible to create different types of content depending on the requirements of each project.Example Content TypesBlog PostsExperimentsCategoriesTagsUsersCustom Content TypesThe goal was to make the CMS behave more like a flexible content platform rather than a fixed application designed around a single website.Custom FieldsI also expanded the field system so that different content types can have their own configurable fields.The goal was to make content modeling more flexible and closer to the experience provided by modern visual website builders.Instead of having a CMS where every collection has a fixed structure, the system can adapt to different content requirements.This makes it easier to create new content models without constantly changing the underlying application structure.Inspired by Webflow and FramerPart of this experiment was inspired by the flexibility of platforms such as Webflow and Framer.I wanted the content-management experience to feel more dynamic while still keeping the advantages of a headless CMS.The goal was not to recreate Webflow or Framer completely.Instead, I wanted to take some of the flexibility that makes those platforms useful and combine it with the developer-focused architecture of Payload.The idea: Combine the flexibility of visual website builders with the control and developer experience of a headless CMS.User ManagementUsers are another important part of the CMS.I added user-related fields and functionality so that content can be associated with users and managed through the CMS.This provides a foundation for building more advanced functionality around:AuthenticationUser profilesContent authorshipPermissionsUser-generated contentRole-based functionalityThis also gives the CMS a foundation that can be extended as future projects require more sophisticated user workflows.Cloudflare DeploymentAfter building the CMS, I wanted to see how far I could take the deployment without adding infrastructure costs.I deployed the project using Cloudflare infrastructure and connected the required Cloudflare services to the backend.The goal was to keep the entire experiment lightweight while still having a real, publicly accessible CMS.The interesting part was getting the application and backend architecture working within Cloudflare's available platform and free-tier capabilities.A Zero-Cost Infrastructure ExperimentFor this experiment, I wanted to avoid spending money on infrastructure.The project was built using open-source software and deployed using available free Cloudflare services and their applicable usage limits.That made it possible to build and deploy the CMS without purchasing a traditional server or paid hosting plan.Important: Free-tier services have their own limits and usage policies. This should not be interpreted as unlimited infrastructure.The goal was simply to see how much could be built and deployed without an initial hosting bill.Why Build My Own CMS?There are already many excellent CMS platforms available.So, why build another one?For me, this experiment was mainly about control and learning.I wanted a CMS that could adapt to the way I work instead of having to adapt my workflow to an existing CMS.Building on top of Payload also meant that I could keep the underlying system open-source and developer-friendly while adding the features and workflow I wanted.What I LearnedThe biggest lesson from this experiment was that building a CMS is not just about creating an admin panel.A real CMS involves many interconnected systems, including:Content modelingRelationshipsAuthenticationUsersPermissionsAPIsStorageDeploymentCachingValidationInfrastructureStarting with an established open-source project such as Payload made it possible to focus more of my time on customization and product-specific functionality rather than rebuilding every foundational CMS feature from scratch.Cloudflare also made the deployment side of the experiment particularly interesting.It allowed me to explore running the application using modern cloud infrastructure without immediately paying for traditional hosting.The ResultThe final result is a customized headless CMS built around Payload CMS with:Dynamic collectionsCustom and configurable fieldsUser fields and user managementHeadless content managementA workflow inspired by Webflow and FramerCloudflare-based infrastructurePublic deploymentOpen-source foundationsZero initial hosting costThe project gives me a flexible CMS foundation that I can continue extending as I build more experiments and websites.What This Experiment Gave MeThis experiment gave me a much better understanding of how modern headless CMS platforms are structured and how an open-source CMS can be transformed into something much more tailored to a specific workflow.Rather than starting from zero, I was able to take an existing open-source foundation, reshape its content-management experience, introduce dynamic content modeling, and deploy the resulting system on modern cloud infrastructure.The result is not intended to replace every existing CMS.It is a CMS built around the way I want to work.Experiment StatusCompleted and DeployedThe CMS is now running as a working infrastructure that I can continue extending as I build new experiments, websites, and custom digital experiences.This project started as an experiment in customization and became a reusable foundation for future work.

#Experiment
Read Notes
Subscribe to
BuildNotes

Join a growing community of more than 10,000+ friendly readers.

ReaderReaderReader
200+ reviews

Each week, I share actionable developer tips, practical tech advice, and highlights from my favourite build logs, directly to your inbox. It’s free, and always will be.

By submitting this form, you’ll be signed up to my free newsletter, which sometimes includes mentions of my developer tools, guides and projects. You can opt-out at any time with no hard feelings 😄 Here’s our privacy policy if you like reading.