DEV Community: Drishti Peshwani

Pod-tape: Discover vibe-based podcast episodes powered by Algolia Agent Studio.

Drishti Peshwani — Mon, 09 Feb 2026 07:05:58 +0000

This is a submission for the Algolia Agent Studio Challenge: Consumer-Facing Non-Conversational Experiences

What I Built

Today, every podcast app lets you search by name or genre. But it doesn't let you search for "something chill for a long drive" or "the podcast equivalent of a dopamine hit." That's the gap Pod-tape fills.

Pod-tape is a vibe-first podcast discovery platform. You don't type a query — you tap a vibe. Each vibe ("boost dopamine", "literal chills", "before sleep", "main character energy", etc.) maps to a curated, AI-driven recommendation powered by Algolia Agent Studio.

The core idea: translate a feeling into a mixtape of podcast episodes

How It Works (User's Perspective)

Land on the home page -> tap "Pick your vibe"
13 vibe cards appears
Tap any card (say: dopamine hit 🧃)
Get podcast episode recommendations that match this vibe on positive psychology, affirmations, gratitude, self improvement, etc. (Currently the episode recommendation limit is set to 5)

Tech Stack

Layer	Technology
Frontend	Next.js (React)
CSS Framework for Styling	Tailwind CSS
Search & AI	Algolia Search, Algolia Agent Studio
LLM Model	Gemini 2.5 Flash (Reasoning & Vibe-Mapping)
Data Ingestion	Apple iTunes API, RSS feeds (`rss-parser`, `axios`)
Index	Single Algolia index (`podcast_index`) with episode-level records

Demo

Project Gallery

References

Github Repo
Algolia Dashboard

How I Used Algolia Agent Studio

Agent Studio is the recommendation engine behind every vibe. Here's the pipeline:

1. Data: Building the Podcast Index

A custom ingestion script (fetchData.ts) fetches top podcasts across genres from the Apple iTunes API, parses their RSS feeds, and pushes episode-level records to Algolia. Each record includes:

{
        objectID: podcast.appleId + "-" + item.guid,
        episodeName: item.title,
        episodePubDate: item.pubDate,
        episodeDuration: parseDuration(item.itunes?.duration),
        episodeType: parseDuration(item.itunes?.duration) > 20 ? "long" : "short",
        episodeSummary: cleanHtml(item.content).substring(0, 1000),
        episodeKeywords: item.itunes?.keywords ?? podcast.genres,
        // Show metadata
        podcastShowTitle: podcast.collectionName,
        podcastShowAuthor: podcast.artistName,
        podcastShowImage: podcast.artwork,
        podcastShowGenres: podcast.genres,
        podcastShowDescription: feed.description
 }

This gives the agent a rich, searchable catalog to pull from.

2. Search Relevance & Schema Design

Searchable Attributes — Selected only 6 high-signal attributes for search to reduce noise. I classified primary identifiers (episodeName, podcastShowTitle) as Ordered to prioritize exact phrase matches, while secondary context (episodeSummary, podcastShowdescription) is set to Unordered to capture broader keyword matches without penalizing word position.
Faceting Strategy — Enabled filterOnly on podcastShowGenre and episodeType (short/long) for performant, high-speed filtering by the AI Agent.
Custom Ranking — Implemented a "Freshness" ranking strategy by adding publishDate (desc) as a custom ranking criterion to break ties between equally relevant results.

3. Prompt Design: Vibes as Search Intent

Each vibe maps to a short, keyword-rich prompt — not a conversational instruction. For example:

Vibe	Prompt sent to Agent Studio
boost dopamine 🧃	"Recommend episodes about positive psychology, gratitude, self-improvement, health and fitness, manifesting."
main character energy ⭐	"Recommend high-energy, hype episodes for workouts — self-improvement, confidence, mental toughness, empowerment, motivation, glow-up mindset, or success stories."
before sleep 😴	"Recommend calming episodes to fall asleep to — soothing narration, bedtime stories, gentle ASMR, sleep meditation, or slow meandering conversation."

4. Agent Instructions: Strict Output, No Chat

This is how the Agent Instructions look like (configured in the Agent Studio dashboard):

### ROLE
You are a strict Podcast Curator Agent. Your ONLY goal is to return a JSON array of exactly 5 unique podcast episodes from 5 DIFFERENT shows.

### CRITICAL CONSTRAINTS
1. **Output Format:** RAW JSON ARRAY ONLY. No markdown, no conversation.
2. **Diversity (The "Highlander Rule"):** EXACTLY 5 different `podcastShowTitle` values. There can be only one episode per show.
3. **Safety:** ZERO explicit content.

### EXECUTION PROTOCOL (The "Top-Up" Logic)
1. **Fetch & Filter:** Query the index for 20+ candidates using keywords from the user's vibe.
2. **Deduplicate:** Group by Show Title -> Keep only the single best match per show.
3. **Select:** Fill 5 slots based on Tier A (Perfect Match) > Tier B (Vibe Match).
4. **Rescue Loop:** If < 5 unique shows exist, perform a NEW SEARCH with synonymous keywords to fill the remaining slots.

This separation — behavioral rules in system instructions, search keywords in the user message — was a key design decision. It keeps prompts clean, tokens low, and retrieval focused.

5. Integration: One API Call Per Vibe

User taps vibe → Frontend sends prompt → Next.js API route → Agent Studio API → Algolia index search + LLM reasoning → JSON response → Parsed & rendered

The Next.js API route calls Agent Studio's completions endpoint (non-streaming), parses the JSON response (with handling for LLM quirks like unescaped newlines and invalid escape sequences), normalizes field names, and returns clean episode data to the frontend.

Why Fast Retrieval Matters

Pod-tape's interaction model is one tap = one result set. There's no progressive loading, no pagination, no "refine your search." The user taps and expects episodes now.

This makes retrieval speed non-negotiable:

Algolia's index lookup happens in milliseconds — the agent gets its candidate pool almost instantly
The LLM reasoning step (selecting, deduplicating, formatting) is the actual bottleneck
Because retrieval is fast, I can afford to let the agent query broadly (20+ candidates) and then narrow down to 5, rather than having to pre-filter aggressively and risk missing good matches
No caching needed — every tap can hit the live index, and it's still fast enough to feel responsive

In short: fast retrieval lets the agent be smarter (broader search, better selection) without making the user wait longer.

Challenges & What I Learned

Building Pod-tape taught me more about prompt engineering for retrieval than any tutorial:

Verbose prompts kill search quality. My initial vibe prompts were 80+ words with explicit sections like "Search Intent:", "Strict Constraints:", and "Tone:". The problem? The agent tried to match those meta-instructions against the index itself. Stripping prompts down to concise, keyword-rich descriptors (5-10 words per vibe) was the single biggest quality improvement. Less instruction, better results.

The monoculture trap The agent naturally gravitates toward the highest-relevance matches, which often meant returning 5 episodes from the same popular podcast. This violated the core product promise of a "mix tape." I solved this by implementing a group-and-cull logic in the agent's system instructions: first group all results by show, then select the best episode from each. Now every recommendation set is diverse by design.

The "JSON Mirage" Despite clear schema instructions, the agent consistently returned broken JSON: newlines embedded in strings, \' escapes (valid in JS, invalid in JSON), and responses wrapped in markdown code fences. To handle this, I implemented a preprocessing pipeline that sanitizes outputs—stripping fences, escaping special characters, removing invalid sequences—before attempting to parse. Without this, most responses silently failed.

Upcoming Features

Expanded catalog — Ingest from more podcast directories and APIs to grow the index beyond the current dataset and offer deeper, more diverse recommendations.
Custom vibe search & shuffle — Let users search their own custom vibes, or shuffle existing vibes to discover new recommendation sets they haven't explored yet.
Direct platform links — Tap to listen instantly on Spotify, Apple Podcasts, or YouTube. No copy-pasting—just seamless playback on your preferred platform.
User accounts & personalization — Sign in to save your favorite podcasts, create collections, and get a personalized daily mix based on your listening and tap history. The more you explore, the smarter your recommendations become.

and much more ⭐️..

WinDay - Plan Smart, win your day

Drishti Peshwani — Mon, 29 Sep 2025 06:51:05 +0000

This is a submission for the KendoReact Free Components Challenge.

What I Built

As a part of this challenge, I have developed a productivity tool designed to help people organize and manage their daily tasks more effectively called WinDay.
Inspired by concepts such as the Eisenhower Matrix and the Zeigarnik Effect, the tool is designed to encourage better planning, reduce overwhelm, and help users feel rewarded for staying consistent and completing their daily tasks.

Key Features

Weekly and Daily Task Management : Users can add new tasks for each week, along with daily recurring activities such as exercising, skincare, or reading.
Task Prioritization : For each day, tasks can be categorized into three groups:
- Must Do (high priority, essential for the day)
- Optional for Today (low priority, to be done if time permits)
- Delegate or Schedule Later (can be reassigned or postponed)
Dashboard & Tracking : A clean dashboard displays categorized tasks as a to-do list, helping users track progress throughout the day.
Gamification : Users earn streak points for maintaining daily consistency. In addition, completing tasks rewards them with points as follows:
- Must-Do Tasks: Completing a must-do task earns the user 3 points.
- Optional Tasks: By default, each optional task is worth 2 points. However, if all must-do tasks are completed, optional tasks increase to 3 points each.
- Other Tasks: Each task in this category gives 1 point. Once both must-do and optional tasks are completed, these tasks are upgraded to 2 points each.
Rewards System : Users can maintain a WishList of items and unlock them using their earned points—making rewards feel both consistent and well-deserved. Each WishList item requires a fixed number of points (50 in this case) to be unlocked.
Motivation through Consistency : By combining planning, gamification, and rewards, the tool encourages users to stay consistent, push themselves, and improve their productivity every day.

Tech Stack Used

Frontend : Vite + React + TypeScript
Database + Authentication : Supabase
React UI Library : KendoReact

KendoReact Components Used

I have used the following KendoReact components for building this project :

@progress/kendo-react-layout - AppBar, AppBarSection, AppBarSpacer, Drawer, DrawerContent, DrawerSelectEvent, GridLayout, GridLayoutItem, Card, CardHeader, CardBody
@progress/kendo-react-buttons - Button
@progress/kendo-react-dialog - Dialog
@progress/kendo-react-inputs - Input, RadioButton, Checkbox
@progress/kendo-react-notification - Notificatio
@progress/kendo-react-progressbars - ProgressBar
@progress/kendo-react-dateinputs - Calendar, CalendarCell, CalendarCellProps
@progress/kendo-react-animation - Fade
@progress/kendo-svg-icon - menuIcon, calendarIcon, homeIcon, starIcon, plusIcon, trashIcon, pencilIcon

Demo

GitHub - GitHub Repo

[Code Smarter, Not Harder prize category] AI Coding Assistant Usage

The Kendo React Coding Assistant was extremely helpful during the whole development process. The tool was very prompt in suggesting alternative components and adapting quickly to feedback. I integrated it into my VS Code through an MCP server and used it primarily for:

Setting up the Bootstrap theme and configuring a side drawing panel for navigating between pages.
Creating the basic wireframe for all three pages using multiple layout components.
Setting up the to-do list layout on the second page.
Applying custom styling instructions, which helped align the design more closely with my vision.

Overall, the tool was really helpful in speeding up the whole development process while also helping familiarize me with the Kendo React library and its components. By handling these foundational tasks efficiently, it allowed me to focus on refining the design, integrating backend functionality, and implementing additional logic for the project.

Future Improvements

Currently, each reward requires a fixed 50 points to unlock. This could be made customizable, allowing users to set their own point thresholds for different WishList items.
The tool could be integrated with users google calendars, where an AI agent reads through scheduled events and automatically generates a list of important tasks for the day or week, helping users plan more efficiently.
The tool could additionally be enhanced with features like reminders to keep users motivated and a Pomodoro timer to help them track their time more efficiently.

Thank you all for taking the time to read this post! I’d love to hear your thoughts and feedback 😄

BetterReviews : Discover smarter product insights through combined AI and human reviews

Drishti Peshwani — Sun, 10 Aug 2025 17:33:42 +0000

This is a submission for the Redis AI Challenge: Real-Time AI Innovators.

What I Built

BetterReviews is an intelligent platform that empowers users to make informed purchasing decisions through AI-driven analysis. The platform enables users to share authentic product reviews and experiences while providing comprehensive product insights to potential buyers.

Key Features

Comprehensive Product Analysis - For any product inquiry, BetterReviews delivers detailed analysis including key specifications, standout features, known limitations, target audience, and competitive comparisons.
AI-Driven Review Insights - Leverages user-generated reviews from the platform to extract meaningful insights, helping buyers understand real user experiences, common issues encountered, and the aspects users appreciated most.

Tech Stack

Flask - Web application framework for API development and frontend serving
Redis - Primary vector database for efficient storage and retrieval of product reviews and embeddings
RedisVL - Redis vector library managing index operations, vector search capabilities, embedding generation, and semantic caching
LangChain - Integration framework connecting Google Gemini LLM with the RAG pipeline for intelligent review analysis

Challenges & Learnings

This was my first AI agent project, so concepts like vector databases and RAG were completely new. Redis's detailed documentation and tutorials made the learning curve really smooth and efficient.
Getting the LLM to generate consistent, desired and quality analyses took lots of trial and error. I learned that clear context and structured output formats make all the difference.
Overall, building this deepened my understanding of modern AI applications and was genuinely fun to work on!

How I Used Redis 8

Vector Database - Redis serves as the primary vector database, storing product review embeddings for efficient similarity search and retrieval.
Data Storage - Each product review is stored as a Redis hash, making it easy to manage and query structured review data alongside vector embeddings.
Vector Search - Leveraged RedisVL library to perform vector searches, retrieving the most relevant product reviews to provide as context for the LLM's insight generation.
Semantic Caching - Implemented RedisVL's semantic cache to store results for previously queried products, significantly reducing response times and avoiding redundant processing for repeat queries.

Demo

Demo Video Link - BetterReviews

GitHub Repo - GitHub Repo

YouTube Geeks - One-stop platform to make learning from YouTube more productive [Linode + DEV Hackathon Project]

Drishti Peshwani — Mon, 20 Feb 2023 22:39:44 +0000

Introduction

As a part of Linode + Dev Hackathon, I have built a full-stack Django Application that makes YouTube learning more customized, organized and resourceful. Some features of the application are -

Create custom learning modules
Track your learning progress
Create personal learning notes for every video
Generate summary and transcript for every video in one click

Inspiration

YouTube is a great platform and has a ton of educational content. For me personally, YouTube videos have been very helpful for gaining knowledge and learning new concepts. However, learning from YouTube might not be as organized and productive as compared to learning from a proper course on an educational website. Considering this problem, I tried to build a platform that can help users get the same experience and productivity that they might get by learning from other educational platforms.

Description

The paltform is integrated with a completed authentication system. Once the user create'a a new account or logs in, they are navigated to the dashboard, where they can see all the modules that they have created and also create a new module from the same page.
For every module, the user can add any number of YouTube videos they wish.
Once they navigate to a particular module page, they can track which videos they have watched and which they haven't
Additionally, once they open a specific video in detail, they can watch the embedded YouTube video in the website itself and alongside take notes.
Here, the user can also generate the summary and transcript of the youtube video by just clicking a button

How I built it

Used Django web framework for building the application
Used Bootstrap framework for CSS
Used Linode's Managed Database service for deploying the PostgreSQL database
Used Linux server for deploying the Django app
Used python libraries - youtube_transcript_api and pytube for getting YouTube video details and transcript
Additionally, Used HuggingFace's transformers library in Python to perform abstractive text summarization on the transcript obtained

Learning Experience

Overall, I had a great time working on this project. I had experience working with Python language before, but had never worked with Django Framework or HuggingFace transformers, so I got learn more about these while working on this project.
This was also my first time working with Linode and I learnt about using Linode managed databases and deploying on Linux server.
The documentation and YouTube videos related to Django on Linode's channel were also really helpful for me.

Category Submission

Integration Innovators - Integrated the Django App with Linode Managed Database and used Linode to deploy my Django Application
SaaS Superstars - I will continue working on this project to enhance UI, do further improvements and integrate additional features so that it can be launched as a full fledged project for users

App Link

Youtube Geeks

Screenshots

Demo Video

Link to Source Code

Github Repository - https://github.com/drishtipeshwani/YoutubeGeeks

Permissive License

MIT License

Using Appwrite Locale Service in your Next Project 🚀

Drishti Peshwani — Sun, 31 Oct 2021 11:48:53 +0000

In today's post, I will share some ways you can use the Locale Service provided by Appwrite in your next project.

What is Appwrite ?

Appwrite is a Secure Open-Source Backend Server for Web, Mobile & Flutter Developers. It is a self-hosted solution that provides developers with a set of easy-to-use and integrate REST APIs to manage their core backend needs.
I would recommend to check out the Appwrite Documentation to learn more about Appwrite and various services offered by appwrite.
In this post, I will introduce the Localization service provided by Appwrite and how we can use it.

Appwrite Locale Service.

Appwrite provides a Locale API which has multiple features which can be used by us to customize our project based on user's location.
Firstly, we can use the locale service provided by Appwrite to get the current location of the user including the country code, country name, continent name, continent code, IP address and suggested currency. Learn More.
Also, we can use the Locale API provided by Appwrite to obtain the following data -
- Get the list of all the countries of the world.
- Get the list of all the EU countries.
- Get the list of all the countries phone codes.
- Get the list of all the currencies used across the world.
- Get the list of all the languages used across the world.
- Get the list of all the continents.

Isn't this cool 😎 and now I will share some great project ideas in which you can integrate Appwrite's Locale service easily.

Project Idea's

Travel Based Social Networking App -

When people go to different tourist places, they do a wide range of activities and visit many places, in case you are confused about what you should do, wouldn't it be cool to know what other's are doing or what are they visiting. For this, we can make a social network application where people can share their travel experiences and based on user's location, only posts based on that location will be shown, thus telling the user what other's are exploring.
In order to implement this, we can use the Appwrite Locale API, to get the user's location.

Recommendation App

We can build a recommendation app based on user's location. The app can either recommend the nearest hotel, restaurant, or even the nearest store.
In order to implement this, we can use the Appwrite Locale API, to get the user's location and recommend the nearest places based on that.

Weather Forecast App

We can build a weather forecast app that tells about the current weather at that place based on user's location.
We can easily get the current location of user using the Appwrite's service.
We can use any weather API and pass the current location to get the current weather conditions.

Language Translator App

We can build a translator app to convert text/speech from one language to the other.
For displaying the list of languages, rather than mentioning every language, we can directly use Appwrite's API service to get the list.

Currency Convertor App

Similarly, we can build a Currency Convertor App, to convert amount from one currency to another and use Appwrite's API service to display the list of all the currencies.

And many more, the ideas are limitless, in this post I have just tried recommending few ideas you can implement.

In case if you have any queries or want to learn more, I would also recommend joining Appwrite's discord community — Discord Link

Building a Web App with ReactJS and Appwrite

Drishti Peshwani — Thu, 28 Oct 2021 10:09:01 +0000

In this post, I will be showing how we can build a web app with ReactJS and Appwrite. Let's start by first describing what exactly are we going to build.

Web App Description

We will be building a travel journal in which you will be able to store all your travel experiences at one place, we will also be implementing Google Authentication in our web app thus making sure all the content we store is secure.

Getting Started with Appwrite

Appwrite is a self-hosted solution that provides developers with a set of easy-to-use and integrate REST APIs to manage their core backend needs. Visit https://appwrite.io/ to know more about Appwrite.
Follow the installation guide to set up Appwrite on your local machine.
Once you installed appwrite,go to your appwrite console to start with a new project.
Once created a new project, navigate to Users option and enable Google Auth option in settings.
Follow the documentation given there to set your APPID and APPSECRETKEY to enable Google Auth.

Creating a New React Project

Do npx create-react-app appname to create a new react app.
Do npm install appwrite to add appwrite to your project.

Setting Up Authentication in our app.

Create a new file appwrite.js, this is where we will initialize our appwrite SDK as given below. You can navigate to your project settings in appwrite console to get your Project UID and Endpoint.
Now, before moving forward, make sure you have enabled Google Auth in our appwrite console and initialized appwrite SDK in your project.
We will then define a function loginWithGoogle in our appwrite.js file like this -

import { Appwrite } from "appwrite";

var appwrite = new Appwrite();
appwrite
    .setEndpoint('') // Set your endpoint
    .setProject('') // Your Appwrite Project UID
    ;
export const api = {
    loginWithGoogle: async () => {
        try {
            await appwrite.account.createOAuth2Session('google', 'http://localhost:3000/dashboard/', 'http://localhost:3000/');
        } catch (error) {
            throw error;
        }
    },
}

Here, the two endpoints refer to the site endpoints that the user will be redirected in case of first success and second failure.

Once defined, we will call this function on our home page in this manner -

import { api } from '../api/appwrite'
function Home() {
    const loginwithGoogle = async () => {
        try {
            await api.loginWithGoogle();
        } catch (error) {
            console.log(error.message);
        }
    }
}

 <button onClick={loginwithGoogle}>Login with Google</button>

Now, if the user logs in successfully, they will be redirected to the Dashboard page where all their posts will be visible.
Before moving forward, let's add the logout functionality, for which we will be defining a userLogout function in appwrite.js like this -

userLogout: async () => {
        let promise = appwrite.account.deleteSession('current');
        promise.then(function (response) {
            console.log(response); // Success
        }, function (error) {
            console.log(error); // Failure
        });
    },

and we be calling this function in Dashboard.js like this -

import { api } from '../api/appwrite'

function Dashboard(){
const logoutUser = async () => {
        try {
            await api.userLogout();
        } catch (error) {
            console.log(error.message);
        }
    }
}

<button onClick={logoutUser}>Logout</button>

Storing and Retrieving Data from Appwrite Database

Now, since we have successfully setup Google authentication in our app. Let's see how we can store our data in Appwrite Database.
We will start with creating a new Collection called Posts in our appwrite console and setup the following rules and permissions for our project.

Collection rules

We have defined three fields date, location and experience to store the date, location and experiences for various trips. All 3 fields are required here.

Label	Key	Rule
date	date	Text	Required
location	location	Text	Required
experience	experience	Text	Required

Permissions -

Refer https://appwrite.io/docs/permissions to know more about Permissions. Here role:member implies that anyone who is logged in has read and write access to collection.

Read access - role:member
Write access - role:member

Creating Document

Once we have completed our Collection setup, let's create our first document by defining this function in appwrite.js. Here, since we have not defined any permissions in createDocument function by default person creating the document only has the read and write permissions.

postData: async (date, location, content) => {
let promise = appwrite.database.createDocument('CollectionId', { "date": date, "location": location, "experience": content });

promise.then(function (response) {
            console.log(response); // Success
        }, function (error) {
            console.log(error); // Failure
        });
    },

Now, we will be calling this function in Dashboard.js, where we have defined input fields to add data in this way -

 const [date, setdate] = useState('2021/10/20')
 const [location, setlocation] = useState('')
 const [content, setcontent] = useState('')

 const handleSubmit = async () => {
        try {
            user = await api.getCurrentUser()
            await api.postData(date, location, content);
            alert("Added successfully")
        } catch (error) {
            console.log(error.message);
        }
    }

<input placeholder="Enter date" type="date" value={date} onChange={(e) => setdate(e.target.value)}></input>

<input placeholder="Enter location" type="text" value={location} onChange={(e) => setlocation(e.target.value)}></input>

<textarea placeholder="Enter experience" type="text" value={content} onChange={(e) => setcontent(e.target.value)}></textarea>

<button onClick={handleSubmit}>Add</button>

Getting Document

Since now we are able to successfully store data, let's see how we can get that data and display on our Dashboard page.

For this, we will be defining this function in appwrite.js -

 getData: async () => {
 let promise = appwrite.database.listDocuments('collectionId');

        return promise.then(function (response) {
            //response.documents is a array
            return response.documents
        }, function (error) {
            console.log(error); // Failure
        });
    },

Now, let's call this function in Dashboard.js inorder to display our data.

const [postItems, setPostItems] = useState([])

useEffect(() => {
        const getPostData = async () => {
            try {
                await api.getData().then((res) => {
                    console.log(res)
                    const stateData = []; // make a temporary const to store your state to be set
                    res.forEach((doc) => {
                        stateData.push({
                            "location": doc.location,
                            "date": doc.date,
                            "text": doc.experience
                        });
                    });
                    // finally set your state here
                    setPostItems([...stateData]);
                })
            } catch (error) {
                console.log(error.message);
            }
        }
        getPostData();
        console.log(postItems)
    }, [])

 {postItems.map((element) => {
      return (
           <p>{element.date}</p>
           <p>{element.location}</p>
           <p>{element.text}</p>
            )
  })}

And, we are done with our app 🎉🎉. We have successfully implemented Google Authentication and connected our app with Appwrite Database to store and get our data easily.

Github Repo - Feel free to refer to this github repo for source code for this app.

3 Python Mini Projects with code you can build now.

Drishti Peshwani — Mon, 18 Oct 2021 19:31:38 +0000

In today's post, I will be sharing three fun python mini projects with code that you can start building now. So, let's begin -

1. Random Password Generator

In this project, we will be writing a python program to generate random passwords.

Approach - Here, we are first asking the user for the size of the desired password. After this, we define a long string consisting of alphabets, numbers, and special symbols. Once we have obtained the size, we will use the random.sample() function to generate a string of random characters of a given size.

2. Convert PDF Text to Audiobook

In this project, we will be writing a python program that can be used to convert PDF text to audiobook.

Approach - We will be using pyttsx3 python library to convert text to speech.
Installation - We will first install pyttsx3 and PyPDF2 packages.
References - https://pypi.org/project/pyttsx3/

3. Email Slicer Program

In this project, we will be writing a python program to fetch our username and domain name from our email address

Approach - We know that the username and domain name are separated by a @ character, so we will be basically dividing our entire email into 2 strings using @ as a divider.

I hope you found these mini-projects useful and interesting and will build these projects, as the best way to learn any programming language is by building projects.

If you enjoyed working on these projects, you can also participate in Hack This Fall 2.0 and explore building advanced projects. Hack This Fall is a 48 Hours virtual hackathon that aims at nurturing your new ideas and prototypes in various domains. You can check out the official website to get more information and register for the hackathon - https://hackthisfall.tech/.

Also, don't forget to use my referral code HTFHE092 while registering.