The original version proved the demand was real. Nearly 10,000 listings were created, 13,500+ users joined, and StartupBase sent thousands of clicks to products looking for visibility.

But the platform needed to evolve.

Product pages had to be stronger. Discovery needed more structure. Launches needed to last beyond a one-day spike. Founders needed a faster way to submit products and get reviewed.

So I rebuilt it properly.

What changed?

StartupBase 2 is not just a visual refresh. It is a product update focused on launches, discovery, and long-term visibility.

• Better product pages with richer context, media, launch history, and team details.
• More visibility through daily launches, weekly rankings, and monthly rankings.
• Cleaner discovery through topics and curated collections.
• An AI Launch Assistant that helps founders create and submit listings faster.
• Reviews and comments for more community feedback.
• A StartupBase blog for launch strategy, founder stories, product updates, and growth ideas.
• More ways to sign in with Google, LinkedIn, and X.

Why it matters?

A product launch should not disappear after one day.

Good products need more chances to be seen, understood, and revisited after launch day.

That is the problem StartupBase 2 is trying to solve: make launches more useful for founders, and make discovery more useful for people looking for what is new.

Read the full launch story: Introducing StartupBase 2

const map = new Map()

console.log(map.size) // 0

map.set('name', 'Atta')
map.set('age', 34)

console.log(map.size) // 2

The size property provides an integer value representing the number of entries in the Map object.

Unlike the length property of an array, which can be found here, the size property of a map is read-only and cannot be modified:

const map = new Map([
  ['name', 'Atta'],
  ['age', 34]
])

console.log(map.size) // 2

map.size = 6

console.log(map.size) // 2 --> Remains the same

In contrast, the length property of an array is writable and can be assigned a new value to increase or decrease the size of the array:

const numbers = [1, 2, 3, 4]

// Truncate to a 3-element array
numbers.length = 3

console.log(numbers)
// [1, 2, 3]

// Increase the size to 5
numbers.length = 5

console.log(numbers);
// [1, 2, 3, <2 empty items>]

To learn more about the Map object and how to create collections of key-value pairs in JavaScript, you can refer to this article.

const map = new Map([
  ['name', 'Alex Hales'],
  ['age', 27],
  ['country', 'United States']
])

console.log(map)
// Map(3) {
//   'name' => 'Alex Hales',
//   'age' => 27,
//   'country' => 'United States'
// }

console.log(map.delete('name')) // true
console.log(map.delete('name')) // false (already removed)
console.log(map.delete('job')) // false (not found)

To delete all elements in a Map object, the clear() method can be used:

const map = new Map([
  ['name', 'Alex Hales'],
  ['age', 27],
  ['country', 'United States']
])

map.clear()

console.log(map.size) // 0
console.log(map) // Map(0) {}

To gain a deeper understanding of the Map object and how to create collections of key-value pairs in JavaScript, refer to this article.

1. Using the entries() method and next():

const map = new Map([
  ['name', 'Alex Hales'],
  ['age', 27],
  ['country', 'United States']
])

const first = map.entries().next().value

console.log(first)
// ['name', 'Alex Hales']

The entries() method returns an iterator object with key-value pairs. By calling next() once, you can retrieve the first element from the iterator.

1. Converting to an array and accessing the first element:

const map = new Map([
  ['name', 'Alex Hales'],
  ['age', 27],
  ['country', 'United States']
])

const first = Array.from(map)[0] // or [...map][0]

console.log(first)
// ['name', 'Alex Hales']

By using Array.from(map) or the spread operator (...map), you can convert the Map object into an array. Then, accessing the element at index 0 will give you the first key-value pair.

1. Using array destructuring with keys() or values():

const map = new Map([
  ['name', 'Alex Hales'],
  ['age', 27],
  ['country', 'United States']
])

const [firstKey] = map.keys()
console.log(firstKey); // 'name'

const [firstVal] = map.values()
console.log(firstVal); // 'Alex Hales'

You can utilize array destructuring to extract the first key or value by calling keys() or values() on the Map object.

To learn more about the Map object and working with key-value pairs in JavaScript, you can refer to this article.

const map = new Map()

map.set('name', 'John Doe')
map.set('age', 29)
map.set('job', 'UX Designer')

console.log(map.get('name')) // John Doe
console.log(map.get('age')) // 29
console.log(map.get('job')) // UX Designer

console.log(map.get('address')) // undefined

If the value associated with the specified key is an object, the get() method returns a reference to that object. Any modifications made to the object will be reflected inside the Map object as well:

const product = { name: 'Milk', qty: 2 }
const prices = [2.99]

const items = new Map()
items.set('product', product)
items.set('prices', prices)

items.get('product').qty = 100
items.get('prices').push(4.55)

console.log(product)
// { name: 'Milk', qty: 100 }

console.log(prices)
// [ 2.99, 4.55 ]

To delve deeper into the Map object and discover more about creating collections of key-value pairs in JavaScript, you can refer to this article.

const map = new Map([
  ['name', 'Alex'],
  ['scores', [75, 87]],
  ['bio', { age: 27, country: 'Pakistan' }]
])

console.log(map)
// Map(3) {
//   'name' => 'Alex',
//   'scores' => [75, 87],
//   'bio' => { age: 27, country: 'Pakistan' }
// }

// Update name (STRING)
map.set('name', 'Alex Hales')
console.log(map.get('name')) // Alex Hales

// Update scores (ARRAY)
map.set('scores', [...map.get('scores'), 99])
console.log(map.get('scores')) // [75, 87, 99]

// Update bio (OBJECT)
map.set('bio', { ...map.get('bio'), job: 'Engineer' })

console.log(map.get('bio'))
// { age: 27, country: 'Pakistan', job: 'Engineer' }

In the above example, the name, scores, and bio elements are updated with new values using the set() method. The name is updated with a string value, scores with an array value by spreading the existing scores and adding a new score of 99, and bio with an object value by spreading the existing bio object and adding a job property.

You can also use the set() method to add new elements to a Map object:

const map = new Map([
  ['name', 'Alex'],
  ['scores', [75, 87]],
  ['bio', { age: 27, country: 'Pakistan' }]
])

map.set('email', 'alex@example.com')

console.log(map)
// Map(4) {
//   'name' => 'Alex',
//   'scores' => [75, 87],
//   'bio' => { age: 27, country: 'Pakistan' },
//   'email' => 'alex@example.com'
// }

In this case, the email element is added to the Map object with its corresponding value.

To learn more about the Map object and how to utilize it to create collections of key-value pairs in JavaScript, you can refer to this article.

const map = new Map()

map.set('name', 'John Doe')
map.set('age', 27)
map.set('country', 'Pakistan')

console.log(map)

// Map(3) {
//   'name' => 'John Doe',
//   'age' => 27,
//   'country' => 'Pakistan'
// }

Since the set() method returns the same Map object, you can chain multiple set() calls together to add multiple elements:

const map = new Map()

map.set('name', 'John Doe').set('age', 27).set('country', 'Pakistan')

console.log(map)

// Map(3) {
//   'name' => 'John Doe',
//   'age' => 27,
//   'country' => 'Pakistan'
// }

It’s important to note that Map keys are unique. If you call the set() method multiple times with the same key, it will update the value associated with that key:

const map = new Map()

map.set('name', 'John')
map.set('name', 'John Doe')

console.log(map)

// Map(1) {
//   'name' => 'John Doe'
// }

In the above example, the value for the key 'name' is initially set to 'John', but it is then updated to 'John Doe' in the second set() call.

The Map object allows you to store various types of objects as keys or values, including object literals, arrays, and functions:

const menu = {
  sandwich: '?',
  cookie: '?',
  popcorn: '?'
}

const pizza = () => '?'

const foods = new Map()

foods.set(menu, 5.9)
foods.set(pizza, 'What is Pizza?')

console.log(foods.get(menu)) // 5.9
console.log(foods.get(pizza)) // What is Pizza?

In the above example, an object literal (menu) and a function (pizza) are used as keys in the Map object, and their corresponding values are retrieved using the get() method.

To learn more about the Map object and how to use it to create collections of key-value pairs in JavaScript, you can refer to this article.

Here’s an example of how you can convert a Map to an object using Object.fromEntries():

const map = new Map([
  ['name', 'John Doe'],
  ['age', 20],
  ['job', 'Doctor']
])

const user = Object.fromEntries(map)
console.log(user)
// { name: 'John Doe', age: 20, job: 'Doctor' }

In this example, the Object.fromEntries() method is called with the map object as the argument, which contains key-value pairs. The method converts the map object to an object literal with the same key-value pairs.

The Object.fromEntries() takes an iterable, such as a Map, and returns an object containing the key-value pairs of the iterable:

const kvPairs = [
  ['name', 'John Doe'],
  ['age', 20],
  ['job', 'Doctor']
]

const user = Object.fromEntries(kvPairs)

console.log(user)
// { name: 'John Doe', age: 20, job: 'Doctor' }

In this case, the kvPairs array directly represents the key-value pairs, and Object.fromEntries() converts them into an object.

An alternate approach is to use the Map.forEach() method to iterate over the entries of the Map object and create a new key on the object for each of them:

const map = new Map([
  ['name', 'John Doe'],
  ['age', 20],
  ['job', 'Doctor']
])

const user = {}

map.forEach((value, key) => {
  user[key] = value
})

console.log(user)
// { name: 'John Doe', age: 20, job: 'Doctor' }

If you want to convert the object back to a Map object, you can use the Object.entries() method to get an array of key-value pairs from the object, and then create a new Map using the Map constructor:

const user = {
  name: 'John Doe',
  age: 20,
  job: 'Doctor'
}

const map = new Map(Object.entries(user))
console.log(map)

// Map(3) { 'name' => 'John Doe', 'age' => 20, 'job' => 'Doctor' }

In this example, Object.entries(user) returns an array of key-value pairs, which is then used to create a new Map object.

To learn more about the Map object and how to create collections of key-value pairs in JavaScript, you can refer to this article.

Here’s an example of how you can convert an object to a Map using Object.entries():

const user = {
  name: 'John Doe',
  age: 20,
  job: 'Engineer'
}

const kvPairs = Object.entries(user)

const map = new Map(kvPairs)
console.log(map)

// Map(3) { 'name' => 'John Doe', 'age' => 20, 'job' => 'Engineer' }

In this example, Object.entries(user) returns an array of key-value pairs from the user object, which is then used to create a new Map object using the Map constructor.

Alternatively, you can use the Array.forEach() method to iterate over the object keys and add each key-value pair to the Map using the Map.set() method:

const user = {
  name: 'John Doe',
  age: 20,
  job: 'Engineer'
}

const map = new Map()

Object.keys(user).forEach(key => {
  map.set(key, user[key])
})

console.log(map)
// Map(3) { 'name' => 'John Doe', 'age' => 20, 'job' => 'Engineer' }

In this example, Object.keys(user) returns an array of keys from the user object. We then iterate over these keys using forEach() and use the Map.set() method to add each key-value pair to the map object.

If you want to convert the Map object back to an object, you can use the Object.fromEntries() method:

const map = new Map([
  ['name', 'John Doe'],
  ['age', 20],
  ['job', 'Engineer']
])

const user = Object.fromEntries(map)

console.log(user)
// { name: 'John Doe', age: 20, job: 'Engineer' }

The Object.fromEntries() method takes an iterable of key-value pairs, such as an array, and returns a new object with the key-value pairs.

To learn more about the Map object and how to create collections of key-value pairs in JavaScript, you can refer to this article.

const users = [
  { name: 'John Doe', role: 'Admin' },
  { name: 'Alex Hales', role: 'Manager' },
  { name: 'Ali Feroz', role: 'User' }
]

const kvPairs = users.map(u => [u.name, u.role])

const map = new Map(kvPairs)
console.log(map)

// Map(3) {
//     'John Doe' => 'Admin',
//     'Alex Hales' => 'Manager',
//     'Ali Feroz' => 'User'
// }

In the above code, a callback function is provided to the Array.map() method, which is executed for each object in the array. During each iteration, an array is returned containing the key and value for each object, resulting in an array of key-value pairs:

const users = [
  { name: 'John Doe', role: 'Admin' },
  { name: 'Alex Hales', role: 'Manager' },
  { name: 'Ali Feroz', role: 'User' }
]

const kvPairs = users.map(u => [u.name, u.role])
console.log(kvPairs)

// [
//     [ 'John Doe', 'Admin' ],
//     [ 'Alex Hales', 'Manager' ],
//     [ 'Ali Feroz', 'User' ]
// ]

Finally, the resulting array is passed to the Map() constructor to create a new instance of the Map object.

Alternatively, you can use the Array.forEach() method to convert the array of objects to a map. This approach involves three steps:

1. Create an empty map object using the Map() constructor.
2. Use the forEach() method on the array to iterate through all the objects.
3. During each iteration, utilize the Map.set() method to add the key-value pair to the map.

const users = [
  { name: 'John Doe', role: 'Admin' },
  { name: 'Alex Hales', role: 'Manager' },
  { name: 'Ali Feroz', role: 'User' }
]

const map = new Map()

users.forEach(u => {
  map.set(u.name, u.role)
})

console.log(map)
// Map(3) {
//     'John Doe' => 'Admin',
//     'Alex Hales' => 'Manager',
//     'Ali Feroz' => 'User'
// }

For further information on the Map object and its usage for creating collections of key-value pairs in JavaScript, you can refer to this article.