diff --git a/data/blog/js/check-for-at-least-one-capital-letter-in-js.mdx b/data/blog/js/check-for-at-least-one-capital-letter-in-js.mdx
new file mode 100644
index 0000000..e2ac072
--- /dev/null
+++ b/data/blog/js/check-for-at-least-one-capital-letter-in-js.mdx
@@ -0,0 +1,103 @@
+---
+title: 'How to Check for at Least One Capital Letter in JS'
+date: '2024-09-17'
+lastmod: '2024-09-17'
+tags: ['javascript', 'string manipulation', 'regex', 'programming']
+draft: false
+summary: 'Learn efficient methods to verify if a string contains at least one capital letter in JavaScript using regular expressions, built-in methods, and custom functions.'
+layout: 'PostLayout'
+canonicalUrl: 'https://geekskai.com/blog/js/check-for-at-least-one-capital-letter-in-js/'
+---
+
+## Checking for Capital Letters in JavaScript Strings
+
+In web development and data validation, it's often necessary to verify if a string contains at least one capital letter. This requirement is common in password strength checks, form validation, and text processing. In this article, we'll explore various JavaScript methods to accomplish this task efficiently.
+
+### Using Regular Expressions
+
+One of the most powerful and concise ways to check for capital letters is by using regular expressions:
+
+```javascript
+function hasCapitalLetter(str) {
+  return /[A-Z]/.test(str);
+}
+
+console.log(hasCapitalLetter("hello World")); // true
+console.log(hasCapitalLetter("hello world")); // false
+
+```
+
+This regex method is efficient and easy to understand. The pattern [A-Z] matches any uppercase letter from A to Z.
+
+### Utilizing the String.prototype.match() Method
+
+Another approach involves using the match() method with a regular expression:
+```javascript
+function checkForCapital(str) {
+  return str.match(/[A-Z]/) !== null;
+}
+
+console.log(checkForCapital("JavaScript")); // true
+console.log(checkForCapital("javascript")); // false
+
+```
+
+This method returns an array of matches or null if no match is found, making it easy to check for the presence of capital letters.
+
+
+
+
+### Using String Methods
+If you prefer not to use regular expressions, you can achieve the same result using JavaScript's built-in string methods. One approach is to loop through the string and check each character to see if it is an uppercase letter.
+
+Here's how you can do it:
+
+```javascript
+function containsCapitalLetter(str) {
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] >= 'A' && str[i] <= 'Z') {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Example usage
+console.log(containsCapitalLetter("hello World")); // true
+console.log(containsCapitalLetter("helloworld")); // false
+```
+
+In this example, we loop through each character of the string and check if it falls within the range of uppercase letters.
+This method is straightforward and doesn't rely on regular expressions, which can be beneficial in certain scenarios.
+
+### Leveraging String.prototype.toUpperCase()
+
+For a solution without regex, we can compare each character with its uppercase version:
+```javascript
+function hasUpperCase(str) {
+  return str.split('').some(char => char === char.toUpperCase() && char !== char.toLowerCase());
+}
+
+console.log(hasUpperCase("Hello")); // true
+console.log(hasUpperCase("hello")); // false
+```
+
+This method is particularly useful when you need to avoid regular expressions or when working in environments where regex support might be limited.
+
+
+
+### Performance Considerations
+
+When dealing with large strings or frequent checks, performance becomes crucial. Here's a comparison of the methods:
+
+1. Regex test: Generally the fastest for short to medium-length strings.
+2. match() method: Slightly slower than regex test but more versatile.
+3. Loop with character comparison: Can be efficient for short strings but may slow down for very long strings.
+4. toUpperCase() comparison: Can be slower for very long strings but doesn't require regex knowledge.
+
+Choose the method that best fits your specific use case and performance requirements.
+
+## Conclusion
+
+Checking for the presence of at least one capital letter in a string is a common task in JavaScript programming. Whether you prefer the conciseness of regular expressions, the clarity of built-in string methods, or a simple loop-based approach, JavaScript provides multiple ways to achieve this goal efficiently. By understanding these techniques, you can improve your form validation, enhance password security checks, and process text more effectively in your web applications.
+Remember to consider the specific requirements of your project, such as performance needs and code maintainability, when choosing the best method for your use case.
\ No newline at end of file
diff --git a/data/siteMetadata.js b/data/siteMetadata.js
index 22547a1..3d8dc65 100644
--- a/data/siteMetadata.js
+++ b/data/siteMetadata.js
@@ -1,6 +1,6 @@
 /** @type {import("pliny/config").PlinyConfig } */
 const siteMetadata = {
-  title: 'Geeks Kai',
+  title: 'geeks kai',
   author: 'Geeks Kai',
   headerTitle: 'geeks kai Blog',
   description: