DEV Community: Moksh Upadhyay

How I Built My Developer Portfolio (React + Netlify) and What I Improved

Moksh Upadhyay — Tue, 10 Mar 2026 18:00:05 +0000

Recently I spent some time refining my developer portfolio.

Instead of treating it like just another “portfolio page”, I tried to approach it the same way I would approach a real product — thinking about performance, structure, and maintainability.

The result was a series of small improvements that made the site much cleaner and more production-ready.

The Stack I Used
The portfolio itself is built using a pretty simple stack:

React for the UI
Netlify for deployment
Vanilla CSS for styling
JavaScript for interactions

I intentionally kept the stack lightweight so the site remains fast and easy to maintain.

Performance Improvements

One of the first things I noticed was the size of some assets.

For example, my profile image was originally 4.7MB, which is way too heavy for a simple landing page.

After optimizing it, I reduced it to 95KB without noticeable quality loss.
That alone improved the loading experience quite a bit.

I also cleaned up unused assets and simplified the HTML structure to reduce the final bundle size.

Small changes like this make a big difference.

Handling SPA Routing on Netlify

React applications commonly use client-side routing. When deployed on static hosting platforms, refreshing a routed page may result in a 404 error.

Example route:

/project/1

To address this, Netlify redirect rules can be configured so all routes fallback to the main application entry point.

Example configuration:

/* /index.html 200

This allows the React router to manage navigation correctly.

Small UI Improvements

I also added a couple of small UI touches.

The scrollbar changes color based on the theme (light or dark mode), which keeps the interface consistent.

I also made the favicon theme-aware, so it stays visible whether the browser is in light or dark mode.

They’re small details, but they help the site feel more polished.

Spam Protection for the Contact Form
Instead of adding CAPTCHA, I implemented a honeypot field in the contact form.

Basically:
A hidden field is added to the form, Bots usually fill it automatically. If that field has data, the submission gets rejected
It helps filter spam without affecting real users.

Adding Dedicated Project Pages
Originally my portfolio just showed project cards. Now when you click a project, it opens a detailed page explaining the project — including:

why it was built
what technologies were used
what problems came up during development
how those problems were solved

I think projects become much more meaningful when you can see the thinking behind them, not just screenshots.

Why I Treated It Like a Real Project

Even though it’s “just a portfolio”, it’s still a reflection of how you build things.

Things like:

structure
performance
deployment
UX details

These are the same things that matter in real products.
You Can Check It Out Here
If you’re curious, you can see the portfolio here:
👉 https://mokshcodes.netlify.app

🚀 Understanding Strings and Characters in C

Moksh Upadhyay — Sun, 09 Mar 2025 16:34:46 +0000

In C programming, Strings and Characters are fundamental for handling text-based data. But did you know there’s a major difference between 'A' and "A" in C?

✅ 'A' is a Character → Stored as a single byte in memory.
✅ "A" is a String → Stored as two bytes (A + \0).

💡 Memory Representation:

'A' → Stored as ASCII value 65
"A" → Stored as 65 + 0 (null character)
Quick Tip 💡
👉 Always use single quotes for characters ('A').
👉 Use double quotes for strings ("Hello").
👉 C strings always end with a null character (\0).

🔥 Bonus: Want to master Strings in C? Check out my detailed blog where I covered:

✅ String functions like strlen(), strcpy().
✅ Pointer to String (the most powerful technique).
✅ Detailed memory representation for both.
👉 Read my full blog here: Strings and Character in C

How to Swap Variables in C: A Simple Guide

Moksh Upadhyay — Sun, 24 Nov 2024 09:33:47 +0000

Swapping variables is a core concept in programming that comes in handy in many scenarios, such as sorting algorithms, data manipulation, or simply reversing values. If you're a beginner learning C programming, understanding how to swap two variables is essential to building your coding foundation.

In C, swapping two variables can be done in a variety of ways. The most common and straightforward method involves using a temporary variable. This temporary variable holds the value of one of the variables while the other variable's value is assigned to the first. While this approach works well in many cases, it's important to note that C uses a call-by-value mechanism when passing variables to functions. This means changes made inside a function don’t reflect outside of it, which can sometimes confuse beginners.

But fear not! If you want to ensure that the original values are modified, you can use pointers. Pointers allow you to directly access and modify the variables' memory locations, ensuring that the swap is reflected outside the function as well.

There are other advanced techniques, such as swapping using arithmetic or XOR bitwise operations, which eliminate the need for a temporary variable. Each method has pros and cons, depending on the specific use case.

If you want to learn how to implement swapping in C with detailed explanations, code examples, and the pros and cons of each method, be sure to head over to my blog. I walk you through all the different ways to swap variables, ensuring you understand how each approach works and when to use it.

Happy coding, and don’t forget to check out the full tutorial! 🚀

Understanding Electricity Billing: A Comprehensive Guide

Moksh Upadhyay — Fri, 12 Jul 2024 08:09:44 +0000

Electricity billing is a crucial aspect of utility management, involving the calculation of costs based on the amount of electricity consumed by users. This process is essential for both residential consumers and businesses, ensuring accurate invoicing and financial management. In this guide, we'll explore the fundamental principles behind electricity billing systems.

How Electricity Billing Works
Electricity billing typically involves several key components:

Measurement of Electricity Consumption:

Electricity usage is measured in units of kilowatt-hours (kWh). The more electricity consumed, the higher the bill.

Tariffs and Pricing Structures:

Tariffs determine the cost per unit of electricity consumed. These tariffs may vary based on factors such as time of day (e.g., peak vs. off-peak hours) and total consumption levels.

Calculation of Charges:

Once the consumption in kWh is recorded, charges are calculated based on the applicable tariff rates. Additional charges, such as taxes or surcharges, may also apply.

Billing Cycles and Invoicing:

Utility companies typically issue bills periodically (e.g., monthly) to customers based on their consumption during a specific billing cycle. Bills detail the amount of electricity consumed, applicable charges, and payment due dates.

Factors Affecting Electricity Bills
Several factors can influence the amount of an electricity bill:

Consumption Levels: Higher electricity consumption results in higher bills.
Tariff Structures: Different tariffs can significantly impact the cost per unit of electricity consumed.
Seasonal Variations: Electricity usage may fluctuate based on seasonal factors such as heating or cooling needs.
Energy Efficiency: Adopting energy-efficient practices and technologies can help reduce overall consumption and lower bills.

Understanding Your Electricity Bill
To interpret your electricity bill accurately, it's essential to understand the breakdown of charges and the terms used:

Unit Price: The cost per kWh of electricity consumed.
Fixed Charges: Base fees or minimum charges applied regardless of consumption.
Taxes and Surcharges: Additional fees imposed by regulatory authorities or utility providers.

Conclusion
Understanding electricity billing is crucial for consumers and businesses to manage energy consumption effectively and budget accordingly. By grasping the principles of how electricity bills are calculated, you can make informed decisions to optimize energy usage and reduce costs.

For further insights into utility management and related topics, continue exploring resources that deepen your understanding of energy economics and sustainability.

Building a Sleek C++ Calculator: Harnessing the Power of Modular Functions

Moksh Upadhyay — Sat, 06 Jul 2024 12:30:51 +0000

In the world of programming, creating practical applications that demonstrate elegance and efficiency is a testament to skillful craftsmanship. One such project that exemplifies this is building a calculator using C++ and modular functions. In this blog post, we'll explore the journey of constructing a functional calculator from scratch, focusing on the principles of modular programming.

Why Build a Calculator?
While a calculator may seem like a simple tool, its construction offers valuable insights into fundamental programming concepts such as functions, control flow, and data handling. By building a calculator, we not only practice these concepts but also learn how to structure our code in a modular and reusable manner—a cornerstone of software engineering.

Getting Started: Preparation and Environment Setup
Before diving into the implementation, it's essential to set up your C++ development environment. Choose an IDE or text editor with a C++ compiler that suits your preferences. This ensures a smooth development process and efficient coding workflow.

Step-by-Step Guide to Building the Calculator
Designing the Functionality: Begin by outlining the basic functionalities your calculator will support. This typically includes arithmetic operations such as addition, subtraction, multiplication, and division. Plan how users will interact with the calculator through a simple user interface.

Implementing Modular Functions: Modular programming involves breaking down complex tasks into smaller, independent modules or functions. Create separate functions for each arithmetic operation to maintain clarity and reusability in your code.
Handling User Input and Output: Develop mechanisms to receive user input for numbers and operation selection. Use conditional statements (if-else or switch-case) to direct the program flow based on user choices. Ensure robust error handling to manage unexpected inputs effectively.
Testing and Validation: Once the core functionalities are implemented, rigorously test the calculator to ensure accuracy and reliability. Verify edge cases such as division by zero or non-numeric inputs. Debug any issues to achieve a stable and user-friendly application.

Conclusion
Building a C++ calculator using modular functions not only enhances your programming skills but also reinforces essential software development principles. By organizing code into reusable modules, you promote maintainable and scalable application development practices.

Ready to embark on this coding journey? Explore further by implementing additional features or refining the calculator's UI to expand its functionality and usability.

Finding Numbers Divisible by 3 and 5

Moksh Upadhyay — Wed, 03 Jul 2024 13:32:11 +0000

Hey Dev Community!

Are you diving into C programming and looking for a hands-on exercise to sharpen your skills? I've just published a new blog post where I walk you through writing a simple C program to find numbers between 1 and 50 that are divisible by both 3 and 5. This exercise is perfect for beginners aiming to understand loops and conditional statements in C.

In the blog, I cover:

Setting up a for loop to iterate through numbers
Using conditional statements to check for divisibility
Printing the results and counting the qualifying numbers

Check out the full blog here

I'd love to hear your feedback and any questions you may have. Let's learn and code together! 💻🎉

Unveiling the Fibonacci Sequence in C Programming

Moksh Upadhyay — Tue, 02 Jul 2024 17:05:29 +0000

𝐖𝐡𝐚𝐭 𝐢𝐬 𝐭𝐡𝐞 𝐅𝐢𝐛𝐨𝐧𝐚𝐜𝐜𝐢 𝐒𝐞𝐫𝐢𝐞𝐬?
The Fibonacci series is a sequence of numbers where each number is the sum of the two preceding ones. It starts from 0 and 1, and the series looks something like this:
0,1,1,2,3,5,8,13,21,34,…

𝐖𝐡𝐲 𝐢𝐬 𝐢𝐭 𝐈𝐦𝐩𝐨𝐫𝐭𝐚𝐧𝐭?
The Fibonacci series transcends its mathematical roots, manifesting in various natural phenomena and human creations. From the spiral patterns of galaxies to the arrangement of petals in flowers and the proportions of ancient architecture, the Fibonacci sequence embodies a universal pattern recognized across disciplines. In art, its rhythmic progression and harmonious proportions have inspired countless works. In computer science and algorithms, Fibonacci numbers serve as a foundation for efficient problem-solving techniques, from dynamic programming to optimizing recursive functions.

Understanding and generating the Fibonacci series not only deepen one's grasp of mathematical concepts but also nurtures an appreciation for the intricate patterns woven into our world. It encourages creativity in problem-solving and fosters a deeper connection between mathematics and its practical applications.

🚀 Mastering Loop Control in C Programming: Leveraging break and continue 🌟

Moksh Upadhyay — Tue, 02 Jul 2024 05:34:02 +0000

Hey Dev Community! Are you ready to enhance your C programming skills and optimize your code? Today, let's delve into the powerful world of loop control with break and continue statements.

Understanding break and continue
In C programming, break and continue are essential tools for managing loops effectively:

break: This statement allows you to exit a loop prematurely based on a specified condition. It's perfect for terminating loops early when certain criteria are met, ensuring efficient program execution.
continue: Unlike break, continue skips the current iteration of the loop and proceeds directly to the next iteration. This helps in bypassing specific iterations without exiting the loop entirely, enabling selective processing of loop iterations.

Practical Applications
Here’s how you can apply a break and continue in your code:

Input Validation: Use a break to stop processing input when an invalid value is encountered, preventing further unnecessary iterations.
Error Handling: Employ continue to skip over error-prone iterations while continuing to process valid data within the loop, enhancing program robustness and stability.

Benefits of Using Break and Continue
Mastering these loop control statements offers several advantages:

Enhanced Code Efficiency:
Exit loops early or skip unnecessary iterations to optimize program performance.
Improved Code Readability: Clearly define loop termination conditions and iteration skips, making code logic more transparent and maintainable.

Conclusion
Incorporating break and continue statements into your C programming toolkit empowers you to write cleaner, more efficient code. Whether you’re validating input, implementing search algorithms, or handling error conditions, these tools enhance your ability to control loop behavior effectively.

Ready to elevate your programming skills? Dive into my detailed blog post on mastering loop control with break and continue: https://mokshelearning.blogspot.com/2024/07/programn%20to%20show%20the%20usage%20of%20break%20and%20continue.html

Master these fundamental tools and unlock new levels of efficiency and precision in your coding journey!

🌟 Mastering Palindrome Checks in C Programming 🌟

Moksh Upadhyay — Mon, 01 Jul 2024 16:03:22 +0000

Are you ready to dive into the intriguing world of palindrome numbers? In my latest blog post, I've explored how to determine if a number is a palindrome using C programming—a fundamental skill every developer should master.

What are Palindrome Numbers?
Palindrome numbers read the same backward as forward, such as 121 or 12321. They hold a unique place in mathematics and programming, often used in algorithms, data validation, and more.

Implementing a Palindrome Checker in C
I walk you through a step-by-step guide to building a simple yet powerful palindrome number checker in C. From initializing variables to using loops and conditions, you'll gain practical insights into effective coding practices.

Why Learn This?
Understanding palindrome numbers not only sharpens your programming skills but also enhances your ability to tackle algorithmic challenges and improve code efficiency. Whether you're a beginner or an experienced coder, this guide offers valuable insights into C programming and problem-solving.

Ready to unlock the secrets of palindrome numbers in C? Read the full post here and start mastering this essential concept today: https://mokshelearning.blogspot.com/2024/07/blog-post_01.html

Join the discussion and share your insights into palindrome numbers and their applications in programming. Let's explore together how these concepts shape our understanding of coding challenges and solutions.

Checking Armstrong Numbers in C

Moksh Upadhyay — Mon, 01 Jul 2024 08:52:07 +0000

We're excited to share our latest blog post, "Checking Armstrong Numbers in C" with all of you passionate programmers out there! Whether you're just starting your coding journey or you're a seasoned developer, this tutorial is designed to boost your C programming skills.

What's Inside? 🌟

In this comprehensive guide, you'll learn how to write a program to identify Armstrong numbers. These unique numbers are fascinating because the sum of the cubes of their digits equals the number itself. Here's a sneak peek of what you'll find:

Step-by-Step Instructions: Detailed steps to help you understand the logic and flow of the program.
Sample Code: Ready-to-use code snippets that you can try out and modify.
Optimization Tips: Techniques to make your program more efficient and performant.
Critical Thinking Development: Practical, problem-solving approach to enhance your coding and analytical skills.

Why Read This Post? 🤔

Armstrong numbers are a classic problem that every programmer should tackle at least once. By understanding and implementing this algorithm, you'll not only learn about these numbers but also sharpen your critical thinking and problem-solving abilities. This tutorial ensures that you get a hands-on learning experience, making complex concepts easier to grasp.

So, what are you waiting for? Dive into our latest post and take your C programming skills to the next level!

👉 Read the full post here:https://mokshelearning.blogspot.com/2023/06/15-checking-armstrong-numbers-in-c.html

Don't forget to leave your feedback and share your thoughts in the comments! Let's learn and grow together. 💪

Happy coding! 😊