Types of APIs

APIs (Application Programming Interfaces) are a way for two or more computer programs to communicate with each other. They allow developers to access data and functionality from other applications, without having to know the underlying code.

There are many different types of APIs, but some of the most common include:

• REST APIs

  REST APIs are the most popular type of API. They are based on the REST (Representational State Transfer) architectural style, which uses HTTP methods like GET, POST, PUT, and DELETE to access and manipulate data.

  const url = 'https://api.github.com/repos/nodejs/node';
  
  fetch(url)
    .then(response => response.json())
    .then(data => {
      console.log('Repository name:', data.name);
      console.log('Description:', data.description);
      console.log('Stars:', data.stargazers_count);
    })
    .catch(error => {
      console.error('Failed to retrieve data:', error);
    });
        

• SOAP APIs

  SOAP APIs are another type of API that uses XML to exchange data. They are often used in enterprise applications where security and reliability are important.

  const soap = require('soap');
  
  const url = 'http://www.dneonline.com/calculator.asmx?WSDL';
  
  soap.createClient(url, (err, client) => {
    if (err) {
      console.error('Error creating SOAP client:', err);
      return;
    }
  
    client.Add({ intA: 5, intB: 3 }, (err, result) => {
      if (err) {
        console.error('Error calling SOAP API:', err);
        return;
      }
      console.log('Result of Addition:', result.AddResult);
    });
  });
        

• GraphQL APIs

  GraphQL APIs are a newer type of API that allows clients to request only the data they need. This can be more efficient than REST APIs, which often return more data than is needed.

  const url = 'https://api.spacex.land/graphql/';
  
  const query = `
    query {
      launchesPast(limit: 2) {
        mission_name
        launch_date_local
        launch_site {
          site_name_long
        }
      }
    }
  `;
  
  fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ query })
  })
    .then(response => response.json())
    .then(data => {
      data.data.launchesPast.forEach(launch => {
        console.log('Mission:', launch.mission_name);
        console.log('Launch Date:', launch.launch_date_local);
        console.log('Launch Site:', launch.launch_site.site_name_long);
        console.log(' ');
      });
    })
    .catch(error => {
      console.error('Failed to retrieve data:', error);
    });
        

• WebSocket APIs

  WebSocket APIs are used for real-time communication between clients and servers. They are often used in chat applications and online gaming.

  const socket = new WebSocket('wss://echo.websocket.org');
  
  socket.addEventListener('open', () => {
    console.log('Connected to WebSocket server');
  });
  
  socket.send('Hello WebSocket!');
  console.log('Message sent!');
  
  socket.addEventListener('message', event => {
    console.log('Message received:', event.data);
  });
  
  socket.addEventListener('close', () => {
    console.log('WebSocket connection closed');
  });
  
  socket.addEventListener('error', error => {
    console.error('WebSocket error:', error);
  });
        

• gRPC APIs

  gRPC APIs are a type of API that uses Protocol Buffers for data serialization. They are often used in microservices architectures.

  service UserService {
    rpc GetUser (UserRequest) returns (UserResponse);
  }
  
  message UserRequest {
    string id = 1;
  }
  
  message UserResponse {
    string name = 1;
    string email = 2;
  }
        

Which type of API is right for you will depend on your specific needs. If you are building a web application, then you will likely want to use a REST API. If you need to exchange data in real time, then you will need to use a WebSocket API.

No matter what type of API you choose, it is important to make sure that it is well-designed and easy to use. A good API will make it easy for other developers to integrate with your application.

I hope this blog post has been helpful. If you have any questions, please feel free to leave a comment below.

JavaScript/TypeScript Project Ideas

JavaScript/TypeScript Project Ideas to Level Up Your Coding Skills

JavaScript/TypeScript are versatile languages that empower you to build everything from interactive websites to robust web applications. Whether you're just starting or looking to refine your skills, working on projects is the best way to learn. Here are JavaScript/TypeScript project ideas, categorized by skill level, to get you coding:

Beginner Projects

• To-Do List
• Speech Detection
• Geolocation
• Movie App
• Password Generator
• Memory Matching Game
• Hangman Game
• Digital Clock with Time Zones
• Pomodoro Timer
• Virtual Keyboard

Intermediate Projects

• Quiz App
• Habit Planner
• Online Markdown Editor
• Interactive Storytelling Platform
• Real-time Polling App
• Social Media Sharing Widgets
• Habit Tracker with Analytics
• Multi-step Form Wizard
• Simulation of a Physics Phenomenon
• Interactive Map with Custom Markers

Advanced Projects

• Maze Game
• Login Authentication
• Hotel Booking App
• Real-time Collaborative Whiteboard
• Music Recommendation System
• Code Snippet Manager with Syntax Highlighting
• Virtual Tour for tourism places
• Prompt Generator
• VR Gallery
• Blockchain-based Supply Chain Tracker

Remember, the best project is one that excites you! So pick an idea that sparks your interest and start coding. Happy developing!

JSON Web Token (JWT)

What is JSON Web Token?

JSON Web Token (JWT) is an open standard that defines a compact and self-contained way for securely transmitting information between parties as a JSON object. This information can be verified and trusted because it is digitally signed.

When should you use JSON Web Tokens?

• Authorization: This is the most common scenario for using JWT. Once the user is logged in, each subsequent request will include the JWT, allowing the user to access routes, services, and resources that are permitted with that token.
• Information Exchange: JWT are a good way of securely transmitting information between parties. Because JWT are digitally signed, you can be sure that the sender is who they say they are, and that the message hasn't been changed in any way.

What is the JSON Web Token structure?

In its compact form, JWT consist of three parts separated by dots (.), which are:

• Header
• Payload
• Signature

Therefore, a JWT typically looks like the following: xxxxx.yyyyy.zzzzz

Header

The header typically consists of two parts: the type of the token, which is JWT, and the hashing algorithm being used, such as HMAC SHA256 or RSA.

For example:

{
  "alg": "HS256",
  "type": "JWT"
}
  

Payload

The second part of the token is the payload, which contains the claims. Claims are statements about an entity (typically, the user) and additional data. There are three types of claims:

• Registered claims: These are a set of predefined claims which are recommended for implementation.
• Public claims: These can be defined at will by those using JWTs.
• Private claims: These are custom claims created to share information between parties that agree on using them.

For example:

{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
}
  

Signature

To create the signature part you have to take the encoded header, the encoded payload, a secret, the algorithm specified in the header, and sign that. For example if you want to use the HMAC SHA256 algorithm, the signature will be created in the following way:

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret)
  

The signature is used to verify that the sender of the JWT is who they say they are, and that the message hasn't been changed in any way.

How do JWTs work?

In a typical authentication flow, the user uses their credentials to log in. Once the user is logged in, the server creates a new JWT and sends it back to the client. The client then stores the JWT and includes it in the Authorization header of each subsequent request. The server verifies the signature of the JWT to ensure that it is valid.

The following diagram shows how JWTs are typically used:

JWTs are a powerful tool for authentication and authorization. They are lightweight, secure, and easy to use. If you are building a web application that needs to be secure, JWTs are a great option.

7 New CSS Features You Need to Know

CSS is constantly evolving, with new features being added all the time. In this post, we'll take a look at 7 of the most exciting new CSS features that you need to know about. These features will help you create more modern, responsive, and user-friendly websites.

1. Light-dark() function

The light-dark() function allows you to easily create styles that adapt to the user's preferred color scheme. For example, you can use it to set different background and text colors for light and dark modes.

    body {
      background-color: light-dark(white, black);
      color: light-dark(black, white);
    }

2. New CSS pseudo-classes: :user-valid and :user-invalid

These new pseudo-classes allow you to style form elements based on whether the user has entered valid or invalid data. This can be used to provide real-time feedback to the user and make forms more user-friendly.

    input:user-valid {
      border-color: green;
    }
    input:user-invalid {
      border-color: red;
    }

3. interpolate-size property

The interpolate-size property makes it easy to animate the size of elements. This can be used to create smooth transitions and make your designs more dynamic.

    panel {
      interpolate-size: height 0.5s ease;
    }
    panel.open {
      height: auto;
    }

4. align-content property

The align-content property can be used to center elements in block layouts. This can be used to create more balanced and visually appealing layouts.

    my-element {
      display: block;
      align-content: center;
    }

5. @property at-rule

The @property at-rule allows you to define custom CSS properties. This can be used to create more modular and maintainable CSS code.

    @property --rotation {
      syntax: '';
      inherits: false;
      initial-value: 0deg;
    }
    div {
      transform: rotate(var(--rotation));
    }

6. @starting-style rule

The @starting-style rule allows you to define the initial state of an element. This can be used to create smooth transitions and avoid the Flash of Unstyled Content (FOUC).

    @starting-style {
      .modal {
        opacity: 0;
        visibility: hidden;
      }
    }
    .modal {
      opacity: 1;
      visibility: visible;
      transition: opacity 0.3s ease, visibility 0.3s ease;
    }

7. Advanced CSS math functions

CSS now supports a number of advanced math functions, such as round(), mod(), and rem(). These functions can be used to create more complex and dynamic layouts.

    .box {
      margin: round(2.5px); /* Rounds to 3px */
    }
    .stripe:nth-child(odd) {
      left: calc(var(--index) * 50px mod 200px);
    }
    .circle {
      width: rem(10px, 3px); /* Outputs 1px */
    }

These are just a few of the many new CSS features that are available. By using these features, you can create more modern, responsive, and user-friendly websites.

Master JavaScript with these slim, practical tips to make your code more efficient, readable, and maintainable.

Slim JavaScript Tips for Cleaner Code

Master JavaScript with these slim, practical tips to make your code more efficient, readable, and maintainable.

1. Use async/await for Asynchronous Requests

Why? Using async/await makes your code more readable and easier to maintain compared to using .then() and .catch().

Best Practice: Always use async/await syntax with Axios requests for better readability and error handling.

const fetchData = async () => {
	try {
		const response = await axios.get('https://api.example.com');
		console.log(response.data);
	} catch (error) {
		console.error('Error fetching data:', error);
	}
};
    

2. Handle Errors Gracefully

Why? Proper error handling ensures your app recovers gracefully from network issues or API errors.

Best Practice: Always use try...catch with async/await and leverage Axios error properties for debugging.

const fetchData = async () => {
	try {
		const response = await axios.get('https://api.example.com');
		console.log(response.data);
	} catch (error) {
		if (error.response) {
			// Server responded with a status other than 2xx
			console.error('Server Error:', error.response);
		} else if (error.request) {
			// No response was received
			console.error('Network Error:', error.request);
		} else {
			// Something went wrong while setting up the request
			console.error('Error:', error.message);
		}
	}
};
    

3. Set Default Configuration for Common Requests

Why? Setting defaults prevents redundancy and keeps your code DRY (Don't Repeat Yourself).

Best Practice: Use Axios defaults to set common headers, base URLs, or other configurations.

axios.defaults.baseURL = 'https://api.example.com/';
axios.defaults.headers.common['Authorization'] = 'Bearer myAuthToken';
axios.defaults.headers.post['Content-Type'] = 'application/json';
    

4. Cancel Requests to Avoid Memory Leaks

Why? Canceling requests prevents memory leaks, especially in single-page apps.

Best Practice: Use CancelToken to cancel Axios requests when no longer needed.

const source = axios.CancelToken.source();

const fetchData = async () => {
	try {
		const response = await axios.get('https://api.example.com/data', {
			cancelToken: source.token,
		});
		console.log(response.data);
	} catch (error) {
		if (axios.isCancel(error)) {
			console.log('Request canceled: ', error.message);
		} else {
			console.error('Error: ', error);
		}
	}
};

// To cancel the request
source.cancel();
    

5. Throttle and Debounce Requests

Why? Throttling and debouncing minimize server requests, improving performance.

Best Practice: Use Lodash’s _.debounce or _.throttle to control request frequency.

const fetchData = _.debounce(async () => {
	try {
		const response = await axios.get('https://api.example.com/data');
		console.log(response.data);
	} catch (error) {
		console.error(error);
	}
}, 500);
    

6. Timeout for Requests

Why? Setting a timeout prevents your app from hanging due to network issues.

Best Practice: Use the timeout configuration to limit request duration.

axios.get('https://api.example.com/data', {
	timeout: 5000, // Timeout after 5 seconds
})
.then(response => {
	console.log(response.data);
})
.catch(error => {
	console.error('Error:', error);
});
    

7. Use Response Data Transformation

Why? Transform response data when APIs return it in an unusable format.

Best Practice: Use transformResponse to modify data before use.

axios.get('https://api.example.com/data', {
	transformResponse: [(data) => {
		const parsedData = JSON.parse(data);
		// Return only the 'items' from the response
		return parsedData.items;
	}]
})
.then(response => {
	console.log(response.data); // Just 'items'
});
    

8. Use withCredentials for Cross-Domain Requests

Why? Send credentials like cookies for cross-domain requests.

Best Practice: Set withCredentials to true when needed.

axios.get('https://api.example.com/data', {
	withCredentials: true, // Send cookies with the request
})
.then(response => {
	console.log(response.data);
});
    

5 Super Useful JavaScript Cheatsheet

1. Array Methods

[1, 2, 3].length; // 3
[1, 2, 3].push(4); // [1, 2, 3, 4]
[1, 2, 3].unshift(0); // [0, 1, 2, 3]
[1, 2, 3].pop(); // [1, 2]
[1, 2, 3].shift(); // [2, 3]
[1, 2, 3].at(2); // 3
[1, 2, 3].indexOf(3); // 2
[1, 2, 3].includes(3); // true
[1, 2, 3].map(num => num * 2); // [2, 4, 6]
[1, 2, 3].filter((num) => num > 1); // [2, 3]
[1, 2, 3].every((num) => num > 0); // true
[1, 2, 3].some((num) => num > 2); // true
[1, 2, 3].fill(0); // [0, 0, 0]
[1, 2, 3].reduce((acc, num) => acc + num, 0); // 6
[1, 2, 3].concat([4, 5]); // [1, 2, 3, 4, 5]
[1, 2, 3].reverse(); // [3, 2, 1]
[3, 2, 1].sort(); // [1, 2, 3]
[1, 2, 3].join("-"); // "1-2-3"
[1, 2, 3].flat(); // [1, 2, 3]
[1, 2, 3].find((num) => num == 1); // 1
[1, 2, 3].findIndex((num) => num == 2); // 1
[1, 2, 3].toString(); // "1,2,3"
[1, 2, 3].toLocaleString(); // "1,2,3"
[1, 2, 3].slice(1, 2); // [2]
[1, 2, 3].splice(1, 1, "a"); // [1, 'a', 3]
Array.isArray([1, 2, 3]); // true
Array.from("123"); // ['1', '2', '3']
    

2. String Methods

"JavaScript".length; // 10
"JavaScript"[2]; // 'v'
"JavaScript".charAt(2); // 'v'
"JavaScript".charCodeAt(2); // 118
"JavaScript".indexOf("S"); // 4
"JavaScript".toLowerCase(); // 'javascript'
"JavaScript".toUpperCase(); // 'JAVASCRIPT'
"JavaScript".slice(2, 5); // 'vas'
"JavaScript".substring(2, 5); // 'vas'
"JavaScript".substr(2, 2); // 'va'
"JavaScript".concat(" Dev"); // 'JavaScript Dev'
"JavaScript Dev".split(" "); // ['JavaScript', 'Dev']
"JavaScript Dev".includes("Dev"); // true
"Java Dev".replace("Dev", "JS"); // 'Java JS'
"Java Dev".replaceAll("Dev", "JS"); // 'Java JS'
" JavaScript Dev ".trim(); // 'JavaScript Dev'
" JavaScript Dev ".trimStart(); // 'JavaScript Dev'
" JavaScript Dev ".trimEnd(); // ' JavaScript Dev'
"Dev".padStart(10, "*"); // '*******Dev'
"Dev".padEnd(10, "*"); // 'Dev*******'
"JavaScript Dev".startsWith("Java"); // true
"JavaScript Dev".endsWith("Dev"); // true
"JavaScript Dev".repeat(3); // 'JavaScript DevJavaScript DevJavaScript Dev'
"JavaScript Dev".indexOf("JavaScript"); // 0
"JavaScript Dev".lastIndexOf("Dev"); // 11
"JavaScript Dev".search("Dev"); // 11
"JavaScript Dev".includes("Dev"); // true
    

3. Date Methods

Initialization

const date = new Date();
// 2023-04-25T19:27:35.363Z
new Date(1682452894553);
// Sun Apr 25 2023 00:00:00 GMT+0200
new Date("2023-04-25");
// Sun Apr 25 2023 00:00:00 GMT+0200
new Date("2023-04-25T01:10:00");
// Sun Apr 25 2023 01:10:00 GMT+0200
new Date(2023, 3, 25, 1, 10, 0, 0);
// Tue Apr 25 2023 01:10:00 GMT+0200
// year, month, day, hour, min, sec, misc
    

Conversions

date.toString();
// Tue Apr 25 2023 21:27:35 GMT+0200 (Central European Summer Time)
date.toDateString();
// Tue Apr 25 2023
date.toTimeString();
// 21:27:35 GMT+0200 (Central European Summer Time)
date.toISOString();
// 2023-04-25T19:27:35.363Z
date.toLocaleString();
// 4/25/2023, 9:27:35 PM
date.toLocaleDateString();
// 4/25/2023
date.toLocaleTimeString();
// 9:27:35 PM
date.getTime();
// 1682452895363
    

Get Methods

date.getFullYear();    // 2023
date.getMonth();    // 3
date.getDate();    // 25
date.getDay();    // 2
date.getHours();    // 21
date.getMinutes();    // 27
date.getSeconds();    // 35
date.getMilliseconds();    // 363
date.getTime();    // 1682452895363
date.getTimezoneOffset();    // -120
    

Set Methods

date.setFullYear(2023);    // set year
date.setMonth(11);    // set month
date.setDate(1);    // set date
date.setHours(10);    // set hours
date.setMinutes(20);    // set minutes
date.setSeconds(20);    // set seconds
date.setMilliseconds(20);    // set milliseconds
date.setTime(1680153156131);    // set time (milliseconds since Jan 1, 1970)
    

4. DOM Methods

Accessing Elements

document.getElementById("id"); // find element by its id
document.getElementsByClassName("class"); // find elements by class
document.getElementsByTagName("tag"); // find elements by tag name
document.querySelector("selector"); // find first element matching selector
document.querySelectorAll("selector"); // find all elements matching selector
    

Creating/Appending Elements

document.createElement("name"); // create element node
document.createTextNode("text"); // create text node
elem.appendChild(child); // append child to element
elem.removeChild(child); // remove child from element
elem.replaceChild(newChild, oldChild); // replace child with new child
    

Modifying Elements

elem.innerHTML = "<h2>outerHTML</h2>"; // set HTML
elem.innerText = "inner text"; // set inner text
elem.textContent = "text content"; // set text content
elem.style.color = "blue"; // set style
elem.outerHTML = "<p>learn with <strong>Athreos</strong></p>"; // replace HTML
			

Accessing Parent, Children, Siblings

elem.parentElement; // access parent element
elem.children; // access element children
elem.firstElementChild; // access first child
elem.lastElementChild; // access last child
elem.nextElementSibling; // access next sibling
elem.previousElementSibling; // access previous sibling
    

Modifying Attributes

elem.getAttribute("attr"); // get attribute value
elem.setAttribute("attr", "value"); // set attribute value
elem.removeAttribute("attr"); // remove attribute
    

Modifying Element Classes

elem.classList.add("my-class"); // add class
elem.classList.remove("my-class"); // remove class
elem.classList.toggle("my-class"); // toggle class
elem.classList.contains("my-class"); // check for class

5. DOM Events

Event Listeners

document.addEventListener('click', (event) => {
	console.log('Click Event', event);
});
// unregister event listener
document.removeEventListener('click', (event) => {
	console.log('Unregistered Event', event);
});

Keyboard Events

keydown // key is pressed down
keyup // key is released

Form Events

blur // element has lost focus
change // value of <input>, <select>, or <textarea> is modified
focus // element has received focus
select // text has been selected in an element
submit // fires on <form> when submitted
reset // fires when form is reset

Mouse Events

click // left mouse button click
dblclick // left mouse button double click
mousedown // pointing device button is pressed when inside element
mouseup // mouse button released over an element
mouseover // mouse pointer enters an element
mousemove // mouse pointer moves over an element

Window Events

abort // resource was not fully loaded, but not due to an error
error // error event occurs if resource failed to load or can’t be used
load // document has finished loading
unload // document is being unloaded
scroll // document is scrolled
resize // window is resized

How to Use Rem Units in CSS?

Rem units are a powerful tool for creating scalable and maintainable CSS. They allow you to size elements relative to the root font size, which makes it easy to adjust the overall size of your website without having to change a bunch of individual element sizes.

Font Sizing

Use rem for font sizes to scale with user settings.

h1 {
      font-size: 2rem; /* 32px if root font-size is 16px */
    }

Media Queries

Use rem in media queries for responsive design.

@media (min-width: 48rem) { /* 768px */
      body {
        font-size: 1.25rem; /* 20px */
      }
    }

Vertical Rhythm in Typography

Maintain vertical spacing with rem.

h2 + * {
      margin-block-start: 0.5rem;
    }

    p + * {
      margin-block-start: 1.5rem;
    }

SVG Scaling

Use rem for consistent SVG sizes.

svg {
      width: 5rem; /* 80px if root font-size is 16px */
      height: 5rem;
    }

Layout Measurements

Use rem for consistent layout dimensions.

.container {
      padding: 2rem; /* 32px */
      margin: 1rem auto; /* 16px auto */
    }

Button Sizes

Ensure buttons are scalable and accessible.

.button {
      padding: 0.5rem 1rem; /* 8px 16px */
      font-size: 1rem; /* 16px */
    }

Grid and Flexbox Units

Use rem for consistent grid and flexbox spacing.

.grid-item {
      flex: 1 1 20rem; /* 320px */
      margin: 1rem; /* 16px */
    }

By using rem units, you can easily control the size of all elements on your page by simply changing the root font size. This makes your CSS more maintainable and scalable, and it also ensures that your website is accessible to users who have different font size preferences.

Why Can't I Crack Job Interviews?

Top 25 interview questions for 2025 with answers

---

1. Why should we hire you?

I bring a unique combination of skills, experience, and a results-driven mindset that align perfectly with this role.

2. What are your salary expectations?

I am open to discussing a competitive package that reflects my skills and industry standards.

3. From your resume, it seems you took a gap year. Would you like to tell us why that was?

I used that time for skill development, personal growth, and aligning my career goals.

4. Describe a time you faced a significant challenge at work.

I used that time for skill development, personal growth, and aligning my career goals.

5. Why did you decide to apply for this position?

This role aligns with my skills, passion, and career aspirations, making it an ideal opportunity for me.

6. Why do you want to work here?

I admire your company's vision, values, and impact, and I'm eager to contribute meaningfully to its growth.

7. What are your strengths and weaknesses?

My strengths include adaptability and problem-solving; my weakness is perfectionism, which I manage by balancing efficiency and quality.

8. What motivates you in your professional life?

Continuous learning, making an impact, and overcoming challenges that drive meaningful results.

9. If you had to choose between a high-paying job you don't enjoy and a lower-paying job you are passionate about, what would you choose?

Passion fuels excellence, so I'd choose a role where I can thrive and add value.

10. Where do you see yourself in 5 years?

Excelling in my field, taking on leadership responsibilities, and making a measurable impact.

11. Why are you leaving your current job?

I seek new challenges, opportunities for growth, and a role that aligns better with my aspirations.

12. What can you offer us that someone else cannot?

A unique mix of expertise, innovation, and a relentless drive to deliver results.

13. How do you stay up to date with industry trends?

By engaging in continuous learning through research, networking, and professional development.

14. How do you prioritize your work?

By assessing urgency, impact, and deadlines while maintaining efficiency and focus.

15. If you were hired, what kinds of goals would you initially have?

Understanding company needs, contributing early wins, and driving long-term value.

16. Why are you looking for a job change?

I'm seeking greater challenges, career progression, and alignment with my long-term goals.

17. How do you manage multiple responsibilities?

Through effective time management, prioritization, and maintaining a structured approach.

18. What sets you apart from other candidates?

My ability to think strategically, adapt quickly, and consistently deliver impact.

19. If you were given a chance to lead a project outside your usual responsibilities, what kind of project would you choose and why?

I'd choose a project that challenges the norm and introduces a smarter, more efficient way of working.

20. When it comes to career development, how are you hoping to grow?

By gaining expertise, expanding my leadership abilities, and contributing at a higher level.

21. How do you deal with pressure or stressful situations?

I stay calm, focus on solutions, and break tasks into manageable steps.

22. If you could redesign your current (or previous) job role, what changes would you make and why?

I would streamline workflows, reduce repetitive tasks, and introduce better collaboration tools to improve efficiency and productivity.

23. If you were given unlimited resources to complete a project, what would be your first three steps and why?

First, define clear goals to ensure alignment. Second, build the right team for execution. Third, create a strategic roadmap to keep everything on track.

24. What's the biggest risk you've taken in your career, and what was the outcome?

I turned down a safe opportunity to pursue a more challenging role. It was uncertain, but it pushed me to grow, and I ended up achieving more than I expected.

25. Do you have any questions for us?

Yes, I'd love to know more about your team's biggest current challenges and how I can contribute.

Some bad habits that makes Unprofessional

8 Silent Habits That Make You Look Unprofessional

Habit #1: The Chronic Late Show

Wasting people's time makes you look careless.

How to fix it:

• • Show up 3-5 minutes early.
• • Review the agenda beforehand and contribute meaningfully.

Habit #2: Constantly Missing Deadlines

Apologizing excessively can undermine your confidence.

How to fix it:

• • Underpromise & overdeliver.
• • Set realistic deadlines and communicate early if delays arise.

Habit #3: Overusing "Sorry" Instead of Owning Up

Apologizing excessively can undermine your confidence.

How to fix it:

• • Replace "Sorry I'm late" with "Thanks for your patience."
• • Own mistakes and focus on solutions.

Habit #4: Email & Messages Ghost Mode

Slow or no responses make you look disengaged.

How to fix it:

• • Acknowledge receipt, even if you need more time.
• • Use a 24-hour response rule.

Habit #5: Empty Promises Syndrome

Saying "I'll do it" and forgetting damages credibility.

How to fix it:

• • Use a task tracker or calendar reminders.
• • Follow up on your promises.

Habit #6: Sloppy Communication

Sloppy, vague, or overly casual emails make a bad impression.

How to fix it:

• • Keep it clear, professional, and to the point.
• • Double-check for tone and typos before hitting send.

Habit #7: Complaining More Than Problem-Solving

Constant negativity makes you the person people avoid.

How to fix it:

• • Raise concerns with solutions in mind.
• • Leaders appreciate proactive thinkers.

Habit #8: Looking Unprepared (Even Virtually)

Showing up looking unpolished affects your credibility.

How to fix it:

• • Dress appropriately for your role & company culture-even on video calls.