Martin  Dreech

Martin Dreech

1560135421

Want to build a chat app with Angular

What we are going to be building

Using our application, users will be able to view and send messages on a private channel.

To achieve this, we are going to be using Pusher's API for sending and receiving messages in realtime. So make sure you have your Pusher account at hand, or sign up for free here. We will also write a tiny server-side Node app that will be used by Pusher to authenticate channel subscriptions received from our Angular front end. Let's look at how these three parts (Pusher, Server, Client) fit together.

Project structure

We are going to keep our server-side and client-side apps separate in their respective directories.

chat-app/
  chat-app-client/
  chat-app-server/

Building a Node app

First, let's get the server app out of the way by creating its directory and initializing npm.

$ mkdir chat-app-server
$ cd chat-app-server
$ npm init

This will create a package.json file for our app. Now let's install our dependencies.

$ npm i --save body-parser express pusher

Note that we are installing the pusher Node library as a dependency.

It's also a good practice to define a npm start script. In our package.json file, let's replace the default scripts property with the following.

// package.json
"scripts": {
  "start": "node server.js"
}

This maps the command node server.js to an npm start command. However, server.js doesn't exist as a file yet, so let's create it next.

// server.js
const express = require('express');
const http = require('http');
const bodyParser = require('body-parser');
const api = require('./api.js');
const port = process.env.PORT || '3000';
const app = express();

// define middleware
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use((req, res, next) => {
res.header(“Access-Control-Allow-Origin”, “*”)
res.header(“Access-Control-Allow-Headers”, “Origin, X-Requested-With, Content-Type, Accept”)
next();
});
app.use(‘/’, api);
app.set(‘port’, port);

const server = http.createServer(app);
server.listen(port, () => console.log(Running on port ${port}));

The calls to our endpoint will be coming in from a different origin, therefore we need to make sure we include the CORS headers (Access-Control-Allow-Origin). If you are unfamiliar with the concept of CORS headers, you can find more information here.

This all is standard Node application configuration, nothing specific to our app.

API Routes

In our server.js file we are referencing a non-existent file api.js on line 5. That’s the file where we will define our API routes and the logic behind them.

// api.js
const express = require(‘express’);
const router = express.Router();
const Pusher = require(‘pusher’);

router.get(‘/’, (req, res) => {
res.send(‘all good’);
});

module.exports = router;

We’ve defined one route for our app: /, that returns an all goodresponse. Now, let’s take a step back and define what we want our API to do based on our requirements.

Pusher Channel Authentication

Considering that we will be triggering Pusher events directly from our client, we need to implement an authentication endpoint. This endpoint will be called by Pusher directly in order to authenticate any subscription it receives from our front end.

Pusher will be making a POST request to an endpoint that we will provide. Therefore, let’s create a POST /pusher/auth endpoint.

// api.js
router.post(‘/pusher/auth’, (req, res) => {
console.log(‘POST to /pusher/auth’);
});

Whenever Pusher calls the authentication endpoint, it sends a socketid and channelname that we will use to authenticate the incoming subscription.

// api.js
router.post(‘/pusher/auth’, (req, res) => {
console.log(‘POST to /pusher/auth’);
const socketId = req.body.socket_id;
const channel = req.body.channel_name;
});

Next step is to authenticate the subscription using the extracted socketId and channel values from the request. Since we will be telling Pusher to authenticate the subscription, we need to initialize Pusher by instantiating it with our Pusher account credentials first. Let’s do that at the top of our api.js file.

// api.js
const pusher = new Pusher({
appId: ‘xxxxxx’,
key: ‘xxxxxxxxxxxxxxxxxxxx’,
secret: ‘xxxxxxxxxxxxxxxxx’,
});

You can find these values by navigating to a specific Pusher application from your personal Pusher dashboard.

We now have an instance of Pusher available to us that we can use for authenticating subscriptions.

// api.js
router.post(‘/pusher/auth’, (req, res) => {
const socketId = req.body.socket_id;
const channel = req.body.channel_name;
const auth = pusher.authenticate(socketId, channel);
res.send(auth);
});

That is all the logic we need to write for our Node app. All that is left now is to run it so that it’s ready to start serving requests. We start our app by running npm start.

Building an Angular web app

As you remember, the client app’s responsibility is to send and receive new messages from Pusher in real time. Let’s get going.

Angular app initialization

We are going to use Angular CLI to quickly scaffold our application. You can follow the installation instructions if you don’t have Angular CLI installed already.

After you’ve installed Angular CLI, it’s time to initialize our Angular application. Navigate to the chat-app directory and run the following command to scaffold an application.

$ ng new chat-app-client --skip-tests --routing

After the installation is finished we need to install Pusher’s client library.

$ npm i --save pusher-js

Installing the library isn’t enough, as we also want to include it on our page. In order to do that we need to add the library to third party scripts to be loaded by Angular CLI. All CLI config is stored in .angular-cli.json file. Modify the scripts property to include the link to pusher.min.js.

// .angular-cli.json “scripts”: [“…/node_modules/pusher-js/dist/web/pusher.min.js”]

We are now ready to write some more code. However, let’s take a step back and figure out the application structure.

Angular application structure

Nothing is stopping us from writing the whole app inside the AppComponent, however, if we want to follow best practices (and we do), then we need to avoid that. AppComponent is best left for any startup initialization we need to do for our app.

Considering that our app is basic, I can only see one other component we can create - MessagesComponent that will be in charge of displaying existing messages, as well as collecting user input and sending new messages.

There will also be one service that we’ll need to create - a PusherService that deals with Pusher.

With CLI, we can easily generate components and services. In our instance, we want to run the following commands.

$ ng g c messages $ ng g s pusher


Note: g is an alias for a generate command, c is an alias for component and s is an alias for a service


We now have all our components in place. Even though our service has been created, it hasn’t been provided. Therefore we need to manually add it as a provider to the correct application module. However, because we only have one module, AppModule, we can only provide it in there.

// app.module.ts
import { PusherService } from ‘./pusher.service’;

@NgModule({
providers: [PusherService],

})

Pusher initialization

First, let’s initialize Pusher. When we were initializing Pusher on the server, we needed three properties: appIdkey and secret, however, we only need the key on the client.

In a real world application, you are likely to use different Pusher keys depending on the environment you are in (like development or production), therefore it is a good idea to store our Pusher key as a property on the environment constant.

Angular CLI creates an environment.ts file that is used to store environment-specific variables. Let’s store our Pusher key there.

// environment.ts
export const environment = {
pusher: {
key: ‘<YOUR_PUSHER_KEY>’,
}
};

Now we can use the environment variable in our PusherService when initializing an instance of Pusher. Upon initialization, we will store it in a property on the service that any other component can use.

// pusher.service.ts
import { environment } from ‘…/environment/environment’;

export class PusherService {
pusher: any;

constructor() {
// replace xxxx’s with your Pusher application key
this.pusher = new Pusher(environment.pusher.key);
}
}

At this point, Typescript will complain about our new Pusher(…) expression, because we haven’t imported Pusher. However, we don’t need to import it, as it exists in the Window object in the browser because we’re including the pusher-js library in our index.html. Therefore, to silence the Typescript compiler, we need to declare Pusher at the top of the file along with other imports.

// pusher.service.ts
declare const Pusher: any;

In addition to the application key, we also need to instantiate Pusher with our authentication endpoint that we created with Node.

constructor() {
// replace xxxx’s with your Pusher application key
this.pusher = new Pusher(‘xxxxxxxxxxxx’, {
authEndpoint: ‘http://localhost:3000/pusher/auth’,
});
}
localhost:3000 is where our Node application is running.

Now we can have access to our pusher instance through the PusherService class.

Pusher works by publishing events to a specific channel. Whoever is subscribed to that channel will receive the published event. Events can have data associated with them. Our client will be receiving and triggering events to a predefined channel. On top of storing the Pusher instance as a property on the PusherService, let’s also store the channel that we will be receiving and triggering messages on.

// pusher.service.ts

export class PusherService {

messagesChannel: any;

constructor() {

this.messagesChannel = this.pusher.subscribe(‘private-messages’);
}
}

It is at this point, during the subscription to a channel that Pusher sends an authentication request to our specified endpoint.

In the snippet above, private-messages is the name of our channel. Triggering events on the front end only works with private or presence channels, therefore we have to prefix our channel’s name with private.

MessagesComponent

Our Angular project was initialized with routing because we passed a –routing flag with the initialization command. However, we need to tell Angular to use our MessagesComponent for the default route. Routing is configured in app-routing.module.ts.

// app-routing.module.ts
import { MessagesComponent } from ‘./messages/messages.component’;

const routes: Routes = [
{
path: ‘’,
component: MessagesComponent,
}
];

Now that MessagesComponent loads for our default route, let’s work on it.

One of this component’s responsibilities is to display existing messages. We could achieve that with an array of messages that we are looping through in the view and display them.

// messages.component.ts

interface Message {
text: string;
user: string;
}
export class MessagesComponent {
messages: Array<Message>;
constructor() {
this.messages = [];
}
}
Note: one of the most powerful Typescript features is (obviously) types. They are there to help you, so make sure you use them. Like in the snippet above, I created an interface for an individual message object. As a result, I can specify that messages property is an array of Message and if I try putting anything else in it - Typescript will not allow me to.

We can now loop over the messages array to display individual messages.

// messages.component.html
<div *ngFor=“let message of messages”>
<b>{{ message.user }}</b>: {{ message.text }}
</div>

Because the messages property is initialized to an empty array, nothing will be displayed. Now that we have a way of storing all messages, let’s write the logic to populate our storage.

Realtime messages from Pusher

New messages are going to be coming in via Pusher. We have the channel that will be transmitting messages and it’s stored in the PusherService. So what we want to do is start listening for events on that channel and handle whenever an event is received.

Because we want to start listening for events on the channel as soon as the MessagesComponent is initialized, we need to use Angular component lifecycle hooks. Specifically, we are interested in the OnInit lifecycle hook, as it is triggered as soon as the component initialization is finished.

Before we use it, we need to let Angular know that we want to be using this hook by specifying that our component implements the OnInit interface.

// messages.component.ts
import { OnInit } from ‘@angular/core’;

export class MessagesComponent implements OnInit {

ngOnInit() {}
}

ngOnInit is the method that will be run when the OnInit lifecycle hook is triggered by Angular. That makes it a perfect place to run any sort of initialization logic, in this case, start listening for events. For that, we need to get access to the messagesChannel property on the PusherService

Before we can use PusherService inside our component, we need to inject it as a dependency of this component.

// messages.component.ts
import { PusherService } from ‘…/pusher.service’;

export class MessagesComponent {

constructor(private pusherService: PusherService) {…}
}

Now we can start listening for events on the messagesChannel property of PusherService.

// messages.component.ts

export class MessagesComponent {

ngOnInit() {
this.pusherService.messagesChannel.bind(‘client-new-message’, (message) => {
this.messages.push(message);
});
}
}

In the snippet above, we are listening for client-new-message events on the messages channel. The second parameter of the bind is the callback function. It is a function that will be called whenever an event is received with the event data. In our case, the data associated with the event will be the message, therefore we are pushing the new message into our array of messages.

Triggering Pusher events

In the MessagesComponent we need to collect the user’s username and message text in order to send it as a new event to Pusher. First, let’s add two input fields in our HTML.

// messages.component.html

<label for=“userName”>Username</label>
<input type=“text” id=“userName” [(ngModel)]=“userName”>

<label for=“message”>Message</label>
<input type=“text” id=“message” [(ngModel)]=“messageText”>

<button (click)=“sendMessage(userName, messageText)”>Send</button>

Two things to note here:

  • We are using Angular’s two-way binding with ngModel to record user input.
  • We have added a click handler on the button that calls a method sendMessage on our component (this method doesn’t exist yet, we will write it soon) with the userName and messageText values.

Because we will be are triggering events directly from the client, we need to prefix the event name with client.

There are also other restrictions that apply when triggering events from the client. Even though I will be pointing them out as we go in this article, I suggest you read the Pusher documentation on the topic to avoid confusion.

Before we can start triggering events from the client, we need to tell Pusher that we intend to do so. You can do that by navigating to your application’s settings on your Pusher dashboard.

Inside our sendMessage method, we will want to trigger an event named client-new-message with the message assembled from this method’s arguments. On top of that, we need to add this message to our array of messages.

// message.component.ts

export class MessagesComponent implements OnInit {

sendMessage(user: string, text: string) {
const message: Message = {
user: user,
text: text,
}
this.pusherService.messagesChannel.trigger(‘client-new-message’, message);
this.messages.push(message);
}
}

Finally, we can send messages and display realtime messages!

You might wonder why are we adding the message that we just triggered an event with to our messages array. Surely, it should come back to us as in our event listener that we’ve defined in the OnInit lifecycle hook of this component?

Well, not exactly. What our event listener does is listen for events on the channel that originated somewhere else, that is a very important aspect. An event from the same origin will not be received on the channel subscription in the same origin.

How can we see our application in all its glory? First, we need to make sure our server is running. Remember, to run it we simply need to run npm start from our chat-app-server directory. Second, we need to run our front-end application, which we can easily do with Angular CLI, by running ng servefrom its root directory. By default, the application will be run on localhost:4200.

Now in order to actually test that our chat application is fully operational, we can open two browser tabs/windows side by side with our Angular application running. Messages sent from one window will appear in another window. Voila, our chat app is fully functional! ?

Congratulations, you have built a chat app. Thank for reading !

Originally published on https://pusher.com


#angular #angular-js #node-js #javascript

What is GEEK

Buddha Community

Want to build a chat app with Angular

Top Enterprise Angular Web Apps Development Company in USA

AppClues Infotech is one of the leading Enterprise Angular Web Apps Development Company in USA. Our dedicated & highly experienced Angular app developers build top-grade Angular apps for your business with immersive technology & superior functionalities.

For more info:
Website: https://www.appcluesinfotech.com/
Email: info@appcluesinfotech.com
Call: +1-978-309-9910

#top enterprise angular web apps development company in usa #enterprise angular web apps development #hire enterprise angular web apps developers #best enterprise angular web app services #custom enterprise angular web apps solution #professional enterprise angular web apps developers

Alex  Sam

Alex Sam

1576484092

Drive Engagement and Interaction Voluntarily via Team Collaboration Chat Apps

Emails are almost extinct. The need to stay glued to your office desk is no more a necessity to stay connected with teams. Chat applications are here and are changing the way teams collaborate and communicate with each other with increased mobility.

Chats have gone a long way from being reserved only for socializing purposes to hosting important team discussions and meetings where ideas are born and rolled out. Team chat apps built for iOS and Android devices are the new collaborative tools that business people thrive on.

Chat apps solutions are seeing technical teams in technology companies, be it startups or an enterprise-grade companies as early adopters as they have started realizing the benefits of flexible and frictionless communication that these chat solutions power.

Advantages that Pose Real-time Instant Messaging Apps as Convenient Alternatives for Group or Team Communication Over Conventional emailing Systems

1. Ad-hoc Conversations
Apart from bringing employees together chat apps pave way for grouping teams for ad-hoc conversations where technical people can discuss over tasks, brainstorm and come up with ideas.

2. Epicenter of Tasks
Through an array of integrations that chat applications offer, teams, especially those involved in product development, can centralize their accounts on other collaborative platforms like GitHub, Jira into the chat application itself creating an ecosystem that caters to all collaboration purposes.

3. Record Keeping and Easy Search
Key developments that happen over a verbal discussion need to be noted down else chances are more likely for losing a crucial breakthrough achieved over a brainstorming session. Team collaboration chat apps record every improvement and contents that dates back to any time can be fully searched.

4. Switch Over Devices Based on Convenience
Multi device compatibility ensures that your employees are connected with teams no matter what devices they are using. If on-the-go connectivity is your preference, get things done on smartphone. If convenience matters the most, switch over to your desktop and continue from where you left.

5. Multiple Communication Medium
Text messages, voice calls, video calls, VOIP calls, direct messages, group chats on iOS and Android extend the modes and medium through which you can get to communicate with your peers, teams and entire organization for that matter.

6. Everything Else that Count
Adding to these, features like file sharing (multiple file types), video conferencing, opinion generation through polls, task delegation, followups, update, personalized notification settings, reminders, to-do list creation and much more can be done through real-time team chat applications.

However, the limitations of team collaboration chat apps end here only if you think so. With every other team, apart from development teams, like those that operational level, management level, marketing level etc can also get to reap the benefits of chat apps. Read on to know the

Instances Which Chat Apps Prove Useful for All Teams in an Organization

Why restrict the benefit of real-time instant messaging chat app to only technology teams into development and designing. Every other team in your office or organization can get a fair share of its advantages.

Here are some of the instances where chat apps can be useful for other teams.
Human Resource team can build employee engagement programs. HRs can get fast response from employees, build a powerful relationship with them, conduct opinion poll for decision making. The hardly-used suggestion box in office premises can be replaced by a chat app for a more effective and instant feedback.

An organization’s system administration team can stay connected with employees on the go and be there on time to resolve issues. Moreover, notifications on breakdowns and other technical issues can help in saving the downtime. Alerts and reminders on instant messaging applications can contribute towards proactive care.

For marketing professionals and sales executives, chat apps on multiple platforms like iOS, Android can reduce series of mail threads into chat logs that are easily searchable. Live video calls and voice calls can help them build better client relationship and both pre and post sales support can get more livelier and personalized with chat apps.

At operational level, chat apps can connect an organization’s representative with many third party vendors to keep up on timely delivery, maintenance, bill payments and more.

Group or Team collaboration applications are the new age communication tools that can contribute for successful communication between employees of an organization in multiple angles. From initiating an idea to getting works done, real time chat apps have started helping organization at many instances which are tough to handle when done conventionally.

If you are into an organization but still have not got a chat app on board, it is high time that your build a chat app on iOS and Android.

#Team Collaboration Chat Apps #real time chat apps #build a chat app #real-time instant messaging chat app #Chat apps solutions

Fredy  Larson

Fredy Larson

1595059664

How long does it take to develop/build an app?

With more of us using smartphones, the popularity of mobile applications has exploded. In the digital era, the number of people looking for products and services online is growing rapidly. Smartphone owners look for mobile applications that give them quick access to companies’ products and services. As a result, mobile apps provide customers with a lot of benefits in just one device.

Likewise, companies use mobile apps to increase customer loyalty and improve their services. Mobile Developers are in high demand as companies use apps not only to create brand awareness but also to gather information. For that reason, mobile apps are used as tools to collect valuable data from customers to help companies improve their offer.

There are many types of mobile applications, each with its own advantages. For example, native apps perform better, while web apps don’t need to be customized for the platform or operating system (OS). Likewise, hybrid apps provide users with comfortable user experience. However, you may be wondering how long it takes to develop an app.

To give you an idea of how long the app development process takes, here’s a short guide.

App Idea & Research

app-idea-research

_Average time spent: two to five weeks _

This is the initial stage and a crucial step in setting the project in the right direction. In this stage, you brainstorm ideas and select the best one. Apart from that, you’ll need to do some research to see if your idea is viable. Remember that coming up with an idea is easy; the hard part is to make it a reality.

All your ideas may seem viable, but you still have to run some tests to keep it as real as possible. For that reason, when Web Developers are building a web app, they analyze the available ideas to see which one is the best match for the targeted audience.

Targeting the right audience is crucial when you are developing an app. It saves time when shaping the app in the right direction as you have a clear set of objectives. Likewise, analyzing how the app affects the market is essential. During the research process, App Developers must gather information about potential competitors and threats. This helps the app owners develop strategies to tackle difficulties that come up after the launch.

The research process can take several weeks, but it determines how successful your app can be. For that reason, you must take your time to know all the weaknesses and strengths of the competitors, possible app strategies, and targeted audience.

The outcomes of this stage are app prototypes and the minimum feasible product.

#android app #frontend #ios app #minimum viable product (mvp) #mobile app development #web development #android app development #app development #app development for ios and android #app development process #ios and android app development #ios app development #stages in app development

How much does an iOS or Android chat app cost to make?

Messaging is one of the most essential functions that smartphone users want to have at hand. Smartphone won’t be a must in our life if it has no chatting function. There is no one that doesn’t have WhatsApp, Viber, WeChat or Snapchat installed on his device. AppClues Infotech has a relevant experience crafting different messaging apps with top-notch technology stacks behind them, and we want to share our insights with you.

We have a team of professional Chat App Developers, experienced Whatsapp clone app developers who works hard on simple as well as complex problem and give their best out of it. Our Chat highly experienced app developers design an application which are elegant, feasible, easy accessible and capability to generate high traffic towards your website.

Ideal features in a Chat app:

  • Instant Messaging
  • Real time connectivity
  • Multimedia file transmission
  • Security
  • Push Notification
  • Quick search
  • Group Chat
  • Video and voice calling
  • Social Integration

The Cost to build an Chat app is between $12 to $15 per hour. The Cost is depends on complexity of a product and feature we need in chat app. The following three factors affect the final cost:

  • Technical complexity
  • The number of devices and OS
  • Custom designs and animations.

Benefits with AppClues Infotech:

  • Steady Mobile Chat App Development Service : Our chatting app development services aim at kickstarting and concluding the app development tasks reliably.
  • Affordable Chatting App Development : It is our vision AppClues Infotech to concentrate on the chat mobile app designing and development in the most affordable way.
  • Guaranteed WhatsApp Chat Clone Security : The specialization of our experts lies in securing the apps with some of the most robust features.
  • Quick Client Support: We at AppClues Infotech take it as our responsibility to provide quick client support in any of the ways required to them.

With its years of expertise in developing messaging/ chatting apps, the AppClues Infotech team of developers has now endeavored into chatting app development. Our sole aim with the messaging apps development is to bring people closer with instant messaging facilities. The app developers at our company have helped us achieve the goal with utmost delicacy.

#cost to make an ios chat app #cost to make an android chat app #cost to build a messaging app #make a messaging app #custom mobile chat app development #how to make a chat app

Carmen  Grimes

Carmen Grimes

1595494844

How to start an electric scooter facility/fleet in a university campus/IT park

Are you leading an organization that has a large campus, e.g., a large university? You are probably thinking of introducing an electric scooter/bicycle fleet on the campus, and why wouldn’t you?

Introducing micro-mobility in your campus with the help of such a fleet would help the people on the campus significantly. People would save money since they don’t need to use a car for a short distance. Your campus will see a drastic reduction in congestion, moreover, its carbon footprint will reduce.

Micro-mobility is relatively new though and you would need help. You would need to select an appropriate fleet of vehicles. The people on your campus would need to find electric scooters or electric bikes for commuting, and you need to provide a solution for this.

To be more specific, you need a short-term electric bike rental app. With such an app, you will be able to easily offer micro-mobility to the people on the campus. We at Devathon have built Autorent exactly for this.

What does Autorent do and how can it help you? How does it enable you to introduce micro-mobility on your campus? We explain these in this article, however, we will touch upon a few basics first.

Micro-mobility: What it is

micro-mobility

You are probably thinking about micro-mobility relatively recently, aren’t you? A few relevant insights about it could help you to better appreciate its importance.

Micro-mobility is a new trend in transportation, and it uses vehicles that are considerably smaller than cars. Electric scooters (e-scooters) and electric bikes (e-bikes) are the most popular forms of micro-mobility, however, there are also e-unicycles and e-skateboards.

You might have already seen e-scooters, which are kick scooters that come with a motor. Thanks to its motor, an e-scooter can achieve a speed of up to 20 km/h. On the other hand, e-bikes are popular in China and Japan, and they come with a motor, and you can reach a speed of 40 km/h.

You obviously can’t use these vehicles for very long commutes, however, what if you need to travel a short distance? Even if you have a reasonable public transport facility in the city, it might not cover the route you need to take. Take the example of a large university campus. Such a campus is often at a considerable distance from the central business district of the city where it’s located. While public transport facilities may serve the central business district, they wouldn’t serve this large campus. Currently, many people drive their cars even for short distances.

As you know, that brings its own set of challenges. Vehicular traffic adds significantly to pollution, moreover, finding a parking spot can be hard in crowded urban districts.

Well, you can reduce your carbon footprint if you use an electric car. However, electric cars are still new, and many countries are still building the necessary infrastructure for them. Your large campus might not have the necessary infrastructure for them either. Presently, electric cars don’t represent a viable option in most geographies.

As a result, you need to buy and maintain a car even if your commute is short. In addition to dealing with parking problems, you need to spend significantly on your car.

All of these factors have combined to make people sit up and think seriously about cars. Many people are now seriously considering whether a car is really the best option even if they have to commute only a short distance.

This is where micro-mobility enters the picture. When you commute a short distance regularly, e-scooters or e-bikes are viable options. You limit your carbon footprints and you cut costs!

Businesses have seen this shift in thinking, and e-scooter companies like Lime and Bird have entered this field in a big way. They let you rent e-scooters by the minute. On the other hand, start-ups like Jump and Lyft have entered the e-bike market.

Think of your campus now! The people there might need to travel short distances within the campus, and e-scooters can really help them.

How micro-mobility can benefit you

benefits-micromobility

What advantages can you get from micro-mobility? Let’s take a deeper look into this question.

Micro-mobility can offer several advantages to the people on your campus, e.g.:

  • Affordability: Shared e-scooters are cheaper than other mass transportation options. Remember that the people on your campus will use them on a shared basis, and they will pay for their short commutes only. Well, depending on your operating model, you might even let them use shared e-scooters or e-bikes for free!
  • Convenience: Users don’t need to worry about finding parking spots for shared e-scooters since these are small. They can easily travel from point A to point B on your campus with the help of these e-scooters.
  • Environmentally sustainable: Shared e-scooters reduce the carbon footprint, moreover, they decongest the roads. Statistics from the pilot programs in cities like Portland and Denver showimpressive gains around this key aspect.
  • Safety: This one’s obvious, isn’t it? When people on your campus use small e-scooters or e-bikes instead of cars, the problem of overspeeding will disappear. you will see fewer accidents.

#android app #autorent #ios app #mobile app development #app like bird #app like bounce #app like lime #autorent #bird scooter business model #bird scooter rental #bird scooter rental cost #bird scooter rental price #clone app like bird #clone app like bounce #clone app like lime #electric rental scooters #electric scooter company #electric scooter rental business #how do you start a moped #how to start a moped #how to start a scooter rental business #how to start an electric company #how to start electric scooterrental business #lime scooter business model #scooter franchise #scooter rental business #scooter rental business for sale #scooter rental business insurance #scooters franchise cost #white label app like bird #white label app like bounce #white label app like lime