Have a checklist

You should already have a checklist while planning.

By checklist, we mean an outline with Todos for the event's preparation. This outline will usually have checkboxes against each Todo. Or you may strikethrough completed tasks.

For example

• Confirm Venue

• Remind food vendors

• Confirm speaker slides

• Remind moderators

• Print Swags

• etc.

Your event will have its unique checklist. This is especially if the event is physical.

If the event is an online session, you can still have a checklist. For example, you should still reach out to the speakers and round up with publicity.

Your checklist stops you from forgetting crucial things. You should have drafted a checklist along the course of planning your event.

You can recreate a checklist for the event day itself. This recreated checklist could contain minor things you want to achieve in the event, like doing a giveaway.

This blog on freeCodeCamp better explains: "Those things you missed — all because you were too cocky to use a checklist".

Have a checklist. Follow it and strikethrough or tick against completed tasks. You'll have a better event-hosting experience.

Day-Before Preparations

Your event is drawing closer. You are getting anxious if it will go on well. You are actively discussing with team members tomorrow will be.

Review your checklist for things that have to be done on the day before the event.

This day is the ideal time to confirm and clean your event venue (for a physical event). It is also the perfect time to confirm the preparations of food vendors and DJs (if you booked any).

The keyword is "confirm". If you need those services, you should have booked them earlier enough. You also want to confirm with event volunteers (or ushers) before the event. Of course, you had agreed with them weeks before now.

If this is an online event, you may want to do a "testing the mic" rehearsal with your speakers. You want to have a short simulation of what the event will look like on the chosen conferencing platform of the event.

In this simulation, you prepare yourself and your speaker(s) for the event. Explain what they should expect and how you will switch mics while on stage. If you have a specific moderator or host, they should be involved at this point.

The day before the event is also the time to peak your event's publicity. You can a design specific flyer for "1-day to go". Just make everyone feel the vibe.

One more thing, please don't panic. Your event will go well.

If in case you come across any disappointment, remember that you are in charge and handle the issue rationally.

Be Early

Wow! The D-day is here. Let's get started.

Be at the event before the start time. Arrange the place. Set up roll-up banners. Your team members should help you. Setup the receptionist volunteers too. Keep swags at the entrance. etc.

Please be early for your event so that you can handle any unforeseen issues with the venue. Even if such issues don't exist, you should be early because you want the best.

By being early, consider being at the event venue for at least an hour before the supposed start time. This will enable you to start the event on time.

If attendees come in later than the start time, it is okay to delay and wait for them before starting the event.

However, it is better that attendees arrive late than that you or the team members are late.

Another advantage of being early is networking. You will have more time to engage with event attendees (in addition to during and after the event).

We can't even overemphasize the indispensability of you being early for your event. It should be taboo if you came late, well except the reasons were worth it.

For an online event, join the meeting before everyone else. You and your hosts and speakers should be there before the attendees join.

If you have a little number of attendees, you can make the space lively by doing small intros or telling short stories while waiting for more people to join. This helps to retain attendees till the end of the event.

Whether online or physical events, please be early!

Following the Agenda

The event agenda is the chronological order of programs during the event. It has the estimate for each program.

Your agenda should be ready before the event day. It is something that you will usually list on the event website or page or in flyers. It gives attendees what to expect in the event.

Your event moderator should follow the agenda. It is okay to deviate a little. Especially if we need to delay as a result of an unforeseen circumstance. Or if a speaker is late and then we swap sessions with a present speaker that was to speak later.

Follow the agenda so that attendees get to receive what they expected during the event. Also, follow the agenda so that the event will achieve its purpose to the fullest.

Following the agenda entails announcing what "we" will be currently doing and doing it. "We" here is everyone at the event.

So when it's time for a speaker's session, the moderator/host will announce the session, introduce the speaker, then usher the speaker in.

After this speaker's session, follow the event's agenda by moving over to the next program on the agenda.

Keep doing this till the event ends.

Social Media Break

Social Media connects people. Today, social media serves as social proof that an event took place.

It is common practice that people take pictures/selfies of themselves at an event and post about it on social media.

You could have a big backdrop for pictures. This backdrop could be somewhere around the venue's entrance. The backdrop usually contains logos of event sponsors. If you had set up this backdrop earlier, attendees will naturally snap with it and post the pictures online.

Nowadays, we tend to be more intentional with social media and posting during events. We could have one or more, 5 or 10-minute breaks where we ask attendees to snap and post on various social media platforms.

This creates more awareness for our community. Consider observing this. Ask the attendees to tag you, your speakers, and or your community's social media accounts while posting.

You may want to have hashtags for the event. Event hashtags are usually based on the event's name or your community's name. You can include these hashtags in the posting instructions.

In fact, at the beginning of the event, you can announce that attendees should be taking pictures and sharing what they learn online as sessions are taking place.

Pictures

Pictures here refer to the ones taken by your planned photography and not by attendees during the social media break.

Planned photography could be a well-setup live streaming, a hired photographer(s), or a volunteer community member(s) with a camera(s).

You want them to capture important moments and highlights during your event.

You can have a volunteer posting these captured moments in real-time on your community (or event)'s social media handles. They can be posted while the event is going on and even after the event.

Find time towards the end of the event to take a group picture too.

Event Dynamics

Things don't always go as planned.

That doesn't mean you shouldn't plan. In fact, planning makes it easy to recover from unexpected disappointments during the event.

By unexpected disappointments I mean issues like:

• dysfunction of the sound system,

• emergency absence of a speaker(s),

• interrupted power supply,

• late delivery by food vendors,

• not enough chairs for attendees,

• etc.

We don't want any of these issues to happen. But as you organize events, one or more of such circumstances will take place.

When they occur, please manage the issue rationally. Rationally here means that you should not allow the circumstance to affect your emotions negatively. Don't let it lower your morale.

Accept it. Face it. And solve the problem. Look for solutions. Ask for help. Your team members and even event attendees can help.

If it is something that the event depends on and it came before the event, it is okay to have an emergency postponement or cancellation of the event. It is also okay to have an emergency change of venue if there is an issue with the chosen venue.

Your attendees will understand when you explain to them your honest efforts toward handling these unexpected circumstances.

Event dynamics is a hidden factor that is not usually discussed. Maybe we tend to ignore them because we kind of take care of them as the event progresses. Then we get carried away.

As a good leader, you will be capable of rationally handling any unexpected circumstances as they happen.

One thing is sure, if you properly plan your event, most of these mishaps won't take place.

Feedback

Feedback helps us evaluate our performance.

Across your planning and as the event is going on, chances are that you have been obtaining feedback from various people.

Watch out for constructive feedback and use it to improve. Discuss with attendees after the event and hear what they have to say about the event they just attended.

You can also get team members or volunteers to extract this info during and after the event.

Make it easy to obtain feedback. Maybe provide a feedback form. Send it via email to attendees. Or share it on social media and ask people to fill it.

Use the feedback you get when planning the next event. You will be capable of creating good event experiences.

Congratulations!

You are Strong!

Kudos!

You are an amazing person.

Look into a mirror. Hit your chest. Be proud of yourself.

You just did something that only a few human beings do.

While anyone can organize and host tech events, not everyone does it.

Find time to relax from the stress that you might have incurred across planning and hosting this event.

Most Importantly: APPRECIATE the event speakers, your team members, and the event volunteers. If you can have the audience clap for them (especially for the volunteers) towards the end of the event, please do.

Don't ignore appreciation. Possibly, gift these people something and send them thank you emails.

If you need to report the event on some dashboard for your community please do so. If you need to record the event on some website for past events, please also do so.

Don't defer these "after-event activities for so long. You may forget or get tired to do them.

Also, if you deem fit, write an article on how you organized the event. Or tell the event's story from your point of view.

Post about the event on social media in your handles. Share the unique organizing experiences you had.

Continue with your community plan/calendar. Start planning for the next event when the time comes.

Events bring community members together. Events permit people to network with each other. As you host events, you do something important to the community, Please keep up.

Thank you for hosting an event.

Cheers!

Major systems have all become digital. Usage of applications keeps increasing. Scaling your apps is now implicit.

Usually, your application will consist of multiple services. These services will each be in charge of doing something different. Let's say you're building a chat application. You could have a messages service, a notification service, a status/stories service, a call service, an authentication service, etc.

One or more of these services have to communicate with each other. You want your app to scale properly. You'll choose the best communication method for your platform's services. You need a message broker.

A message broker is an intelligent middleman for your application's services. A message broker receives "messages" from one or more services. It then delivers these "messages" to other services that want to consume them. This way, your platform scales and meets your users' demands.

A message broker is made up of 3 parts. A queue, producers, and consumers. The queue is the manager of messages. The producers send messages to the queue while the consumers receive them.

What is Memphis Broker?

Memphis is a modern, powerful, and open-source message broker. Memphis takes away the excess work for data engineers and developers. Memphis broker gives you good developer experience. It reduces your development time by 90%.

Memphis is unique. It comes with a UI and a CLI. You can use the UI to visualize the movements of data. You can use the CLI to run important commands on the broker. There is also the sandbox at sandbox.memphis.dev for interacting to see what it looks like without installing it.

Memphis is available for Go, Java, NodeJS, and Python. More platforms will be supported soon. In Memphis, a queue is called a station. And many stations can be found in a factory. When you start using Memphis for the first time, you will at least need to create a factory and a station inside that factory.

How to set up Memphis broker using Docker

Docker is a popular tool for executing and managing software. It provides containers for software execution. It guarantees that a container will have the required dependencies for a given program to run.

You can use Docker to install Memphis. The advantage of using Docker is that you are assured that Memphis will work properly everywhere. Memphis will be the same in your local development and when your app is in production.

To install Memphis, you need to have Docker installed. If you don’t have Docker installed, install Docker for your Operating System here. Start Docker and ensure it's running.

Run the following command in your terminal to install Memphis. It'll fetch the Docker compose file for Memphis set up and set up Memphis appropriately.

curl -s https://memphisdev.github.io/memphis-docker/docker-compose.yml -o docker-compose.yml && docker compose -f docker-compose.yml -p memphis up

If the command completes successfully, Memphis should be up and running in Docker. If you encounter any issues, consider checking your internet connection.

This is a one-time installation of Memphis. In consequent times, when you need to use Memphis, simply launch Docker Desktop and ensure that the Memphis containers are running.

Carry out the following instructions to complete the Memphis setup in the UI:

• Open localhost:9000 in the browser, it should show you the Memphis UI.
• Sign in with root and memphis. These are the default credentials of the “root” user when you set up Memphis with Docker.
• Enter chat as the factory name. Enter chat as the station name. Click “Next”.
• Enter chat as the application user name. Click “Create app user”. It should show you “memphis” as the connection token (password). This is the default.
• Skip through the next steps and access the dashboard.

Note: You can use a different factory, station, and username instead of chat above. We are using chat to keep things simple. Use names that are meaningful to your project. The Memphis UI permits you to manage factories, stations, and users. You can create more users with varying passwords/tokens. This ensures security.

What we will be building

Many applications now need to have a real-time ability. Real-time event-driven architectures use message brokers for many-to-many inter-service communication. Examples of real-time apps include online games, admin dashboards, chat apps, etc.

Let's build a simple chat app. Because it is a simple app, it will have only two services for now. One for all messages and the other for sending messages. The app should have more services but these two are enough to show how to use Memphis.

Let's call this chat app FastChat. In this article, you'll learn how to build FastChat using Memphis broker and NestJS. To keep things simple, FastChat won't save chat messages to any database. It'll keep them in memory while the application is alive. FastChat mainly focuses on showing you how to use Memphis broker.

The final codebase for FastChat is here on GitHub.

What is NestJS?

NestJS is an open-source JavaScript framework for server-side applications. It leverages TypeScript's features to build robust apps. You can structure your Nest project around controllers, modules, and services to properly modularize the code.

FastChat has two services: AllMessages and SendMessage service. These two services will intercommunicate using Memphis broker. We will group them into a Nest module (ChatMessagesModule) because they relate to the same entity.

FastChat also has a BrokerModule. This module will configure Memphis broker. It'll import the MemphisModule and connect the Nest app to Memphis. The BrokerModule will also expose a BrokerService through which other parts of the application can access Memphis.

How to set up NestJS

To install NestJS, you need to have NodeJS installed. If you don't have NodeJS installed, download and install it from here.

To install NestJS, open a new terminal instance and run the following command:

npm install -g @nestjs/cli

Now create a new NestJS project. We will use fast-chat for the project name. Run the following command:

nest new fast-chat -p npm

The -p flag is use npm as package manager. Open the newly created fast-chat project in your favorite code editor.

How to set up the ConfigModule in NestJS

Next, we have to set up Memphis broker inside NestJS. But during the setup, we have to connect NestJS to Memphis broker. For such connection, we need at least three properties:

• host: The domain name or IP address where Memphis is found, e.g. localhost
• username: The user that NestJS will act on their behalf, e.g. root
• connectionToken: The password (token actually) of the above user.

The above three are sensitive information. For security purposes, they shouldn’t be added to source control. Rather, we need to access them through environment variables.

NestJS provides a ConfigModule for providing environment variables. It uses dotenv internally. Create a file with .env as name directly inside the fast-chat project folder. Paste the following inside:

MEMPHIS_HOST=localhost
MEMPHIS_USERNAME=chat
MEMPHIS_TOKEN=memphis

These are the default credentials. You should use more secure credentials in production. That is the very reason of use the ConfigModule in the first place.

Add the NestJS’ ConfigModule to the fast-chat project. Run the following command to install it.

npm install --save @nestjs/config

Import the ConfigModule in AppModule. NestJS auto-created the src/app.module.ts file among other files when we created the project. This file contains the declaration of AppModule. Replace the contents of AppModule with the following:

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  imports: [ConfigModule.forRoot({ isGlobal: true })],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

Here, we are importing the ConfigModule and setting the isGlobal to true. Doing this will auto-import the ConfigModule in all other modules we wil create (which is what we want). In consequent files that need any values from the .env file, you will only access them from ConfigService (coming later on).

How to setup Memphis broker in NestJS Run the following command to install Memphis in FastChat:

npm install --save memphis-dev

Generate the BrokerModule (to set up Memphis) with the following command:

nest generate module broker

This will create a new broker.module.ts file inside a new broker folder. Delete the contents of this new broker.module.ts file and paste the following:

import { Module } from '@nestjs/common';
import { MemphisModule } from 'memphis-dev/nest';

@Module({
  imports: [MemphisModule.register()],
  exports: [BrokerService],
})
export class BrokerModule {}

The above imports and registers the MemphisModule. It also exports a BrokerService (which we will create right away. This BrokerService connects the app to Memphis (when NestJS starts up). This BrokerService is what other parts of the Nest app will use to interact with Memphis.

Run the following command to create the BrokerService:

nest generate service broker

This will create a new broker.service.ts file inside the broker folder. Delete its contents and paste the following:

import { Injectable, OnModuleInit } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { MemphisService } from 'memphis-dev/nest';

@Injectable()
export class BrokerService implements OnModuleInit {
  consumer;
  producer;

  constructor(
    private configService: ConfigService,
    private memphisService: MemphisService,
  ) {}

  async onModuleInit(): Promise<void> {
    try {
      await this.memphisService.connect({
        host: this.configService.get<string>('MEMPHIS_HOST'),
        username: this.configService.get<string>('MEMPHIS_USERNAME'),
        connectionToken: this.configService.get<string>('MEMPHIS_TOKEN'),
      });
      this.consumer = await this.memphisService.consumer({
        stationName: 'chat',
        consumerName: 'chatConsumer',
        consumerGroup: 'chatConsumers',
      });
      this.producer = await this.memphisService.producer({
        stationName: 'chat',
        producerName: 'chatProducer',
      });
    } catch (error) {
      console.error(error);
      this.memphisService.close();
    }
  }
}

The BrokerService imports the ConfigService and the MemphisService. NestJS injects these services using its automatic dependency injection.

The BrokerService implements the OnModuleInit lifecycle method. This is the right place to connect Memphis broker. It is the right place because NestJS calls this method when initializing dependencies. Notice that it connects to Memphis using environment variables from the ConfigService.

The BrokerService also exposes references to the producer and consumer entities of Memphis broker. Other services will use these references to produce or consume "messages" (or events).

Note: Use meaningful consumer and producer names. Use meaningful names that can distinguish which project a particular producer is producing from or from which is a consumer consuming.

Now we've successfully set up Memphis broker. We now need to create the ChatMessages services and link them with Memphis.

But Before we head over to creating services let's review another useful tool. Servers usually expose REST APIs that clients will call. However, there are alternative methods for server-to-client communication. One of such methods is gRPC.

What is gRPC?

RPC means Remote Procedure Call. It means calling a function that is located remotely (in the server).

gRPC is an open-source RPC framework for client-server communication. gRPC exposes server functions or microservices to clients. The clients too use gRPC to access data from the server(s). gRPC is available for all programming languages.

gRPC is faster than REST APIs. It is faster because it uses Protocol Buffers to exchange data (rather than JSON or XML). Protocol Buffers (ProtoBuf) is a neutral way of expressing structured data. ProtoBuf is easy to understand.

FastChat uses gRPC because gRPC is the go-to way for client-server communication in a Service Oriented Architecture (SOA).

How to set up gRPC in NestJS

To set up gRPC, run the following command while inside the fast-chat directory:

npm i --save @grpc/grpc-js @grpc/proto-loader @nestjs/microservices

It adds necessary dependencies for using gRPC in NestJS. Next, create the protobuf (.proto) file for the services in FastChat.

Create a new folder in the src folder, name this new folder chat-message. Create a new file inside this new folder. Name the new file chat-message.proto. Paste the following into this src/chat-message/chat-message.proto

syntax = "proto3";

package ChatMessage;

message Empty { }

message ChatMessage {
  string author = 1;
  string text = 2;
  int64 time = 3;
}

service SendMessageService {
  rpc send (ChatMessage) returns (Empty) {}
}

service AllMessagesService {
  rpc all (Empty) returns (stream ChatMessage) {}
}

This is what protobuf looks like. It is language agnostic. The first line is mandatory and it tells the version of protobuf in use. In this case, "proto3", (the latest version).

message in protobuf refers to a custom type we create. ChatMessage contains an author (a string), the message’s text (string) and when the time the message was sent. int64 is a safe way of representing time as a timestamp.

This protobuf file is not a TypeScript file. By default, NestJS includes all TypeScript files when building the server. If a given NestJS project needs to monitor or include non-TypeScript files into the building process, Nest has to be aware of those files.

The src/chat-message/chat-message.proto above file is an example. To tell Nest about it, add it to the nest-cli.json file. This file is directly inside the fast-chat project folder. Include the following in the JSON file:

  "compilerOptions": {
    "assets": ["**/*.proto"],
    "watchAssets": true
  }

One more config step for gRPC involves adding gRPC as a microservice into NestJS. Delete the contents of src/main.ts file and paste the following:

import { NestFactory } from '@nestjs/core';
import { MicroserviceOptions, Transport } from '@nestjs/microservices';
import { join } from 'path';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.connectMicroservice<MicroserviceOptions>({
    transport: Transport.GRPC,
    options: {
      package: 'ChatMessage',
      protoPath: join(__dirname, 'chat-message/chat-message.proto'),
    },
  });
  await app.startAllMicroservices();
  await app.listen(3000);
  console.log(`Application is running on: ${await app.getUrl()}`);
}
bootstrap();

How to create a service with NestJS

Now that gRPC is properly set up, let's implement our AllMessages and SendMessage services. These services will interact with the ChatMessage type or interface. We need an equivalent of these type in TypeScript (separate from what we declared in protobuf).

Create a new chat-message.interface.ts file inside the chat-message folder. Paste the following inside.

export interface ChatMessage {
  author: string;
  text: string;
  time: number;
}

Next, create a ChatMessagesModule that will contain the AllMessages and SendMessage services. Run the following command to create the module.

nest generate module chat-message

This will create a new chat-message.module.ts file inside the chat-message folder. Given that we will use Memphis broker in the services, import the BrokerModule into this newly generated ChatMessageModule. Delete the contents of the chat-message.module.ts file and paste the following:

import { Module } from '@nestjs/common';
import { BrokerModule } from 'src/broker/broker.module';

@Module({
  imports: [BrokerModule]
})
export class ChatMessageModule {}

gRPC requires that NestJS code implments the methods and services defined in the protobuf file. To implement these services, we will use a controller. A controller in NestJS holds logic for API endpoints. But given that FastChat uses gRPC, the controller will rather hold gRPC functions and services.

Create a new ChatMessageController. Run the following command:

nest generate controller chat-message

It will create a new chat-message.controller.ts file inside the chat-message folder. Replace the contents of this file with the following:

import { Controller } from '@nestjs/common';
import { GrpcMethod } from '@nestjs/microservices';
import { Observable, ReplaySubject } from 'rxjs';
import { BrokerService } from 'src/broker/broker.service';
import { ChatMessage } from './chat-message.interface';

@Controller('chat-message')
export class ChatMessageController {
  private readonly chatMessages$ = new ReplaySubject<ChatMessage>();

  constructor(private brokerService: BrokerService) {}

  onModuleInit(): void {
    this.brokerService.consumer.on('message', (message) => {
      this.chatMessages$.next(
        JSON.parse(message.getData().toString()) as ChatMessage
      );
      message.ack();
    });
  }

  @GrpcMethod('AllMessagesService', 'all')
  all(): Observable<ChatMessage> {
    return this.chatMessages$.asObservable();
  }

  @GrpcMethod('SendMessageService', 'send')
  async send(chatMessage: ChatMessage): Promise<void> {
    await this.brokerService.producer.produce({
      message: Buffer.from(JSON.stringify(chatMessage))
    });
  }
}

ChatMessageController declares a chatMessages$ ReplaySubject. This is an entity that we can push values to and listen to values from.

ChatMessageController obtains the BrokerService via dependency injection. In the OnModuleInit lifecycle hook, we consume “messages” from the BrokerService’s consumer, and emit them to chatMessages$ ReplaySubject. message.ack(); tells Memphis that the “message” is acknowledged (so that it won’t send that “message” again).

ChatMessageController also implements the two communicating services of this real-time app. SendMessageService takes a ChatMessage and produces it to the BrokerService. In turn, AllMessagesService provides as chatMessages$ ReplaySubject as an Observable.

Production and Consumption of broker messages can only be done with strings. This is why we convert ChatMessages to and fro strings when sending and receiving them from the BrokerService’s producer and consumer.

At this point, we’ve successfully setup a simple real-time app with NestJS and Memphis broker.

[Optional]: Test the Real-time chat app with gRPC client

With the way gRPC works, you technically don't make REST API requests. You have to access your backend services from another gRPC SDK (client or server).

We can test the above chat services. One way is to create another gRPC client inside the NestJS project folder. This client will make calls to the services. In turn, you can observe their action in the Memphis Broker UI.

Update the AppModule to import the gRPC ClientsModule. Replace the contents of src/app.module.ts with the following:

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { ClientsModule, Transport } from '@nestjs/microservices';
import { join } from 'path';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { BrokerModule } from './broker/broker.module';
import { ChatMessageModule } from './chat-message/chat-message.module';

@Module({
  imports: [
    ConfigModule.forRoot({ isGlobal: true }),
    BrokerModule,
    ChatMessageModule,
    ClientsModule.register([
      {
        name: 'CHAT_MESSAGE',
        transport: Transport.GRPC,
        options: {
          package: 'ChatMessage',
          protoPath: join(__dirname, 'chat-message/chat-message.proto')
        }
      }
    ]),
  ],
  controllers: [AppController],
  providers: [AppService]
})
export class AppModule {}

Generate a new ClientController that will call the gRPC methods. Run the following command in the terminal:

nest generate controller client

This will create a new client.controller.ts inside a new client folder. Replace the contents of this new file with the following:

import {
  Body,
  Controller,
  Inject,
  OnModuleInit,
  Post,
  Res
} from '@nestjs/common';
import { ClientGrpc } from '@nestjs/microservices';
import { Response } from 'express';
import { firstValueFrom, Observable } from 'rxjs';
import { ChatMessage } from '../chat-message/chat-message.interface';

interface AllMessagesService {
  all(): Observable<ChatMessage>;
}

interface SendMessageService {
  send(chatMessage: ChatMessage): Observable<void>;
}

@Controller('client')
export class ClientController implements OnModuleInit {
  private allMessagesService: AllMessagesService;
  private sendMessageService: SendMessageService;

  constructor(@Inject('CHAT_MESSAGE') private readonly client: ClientGrpc) {}

  onModuleInit(): void {
    this.allMessagesService =
      this.client.getService<AllMessagesService>('AllMessagesService');
    this.sendMessageService =
      this.client.getService<SendMessageService>('SendMessageService');

    this.allMessagesService.all().subscribe((chatMessage: ChatMessage) => {
      console.log(chatMessage);
    });
  }

  @Post('')
  async sendMessage(
    @Body() chatMessage: ChatMessage,
    @Res() res: Response
  ): Promise<void> {
    await firstValueFrom(this.sendMessageService.send(chatMessage));
    res.json({ status: true, message: 'Acknowledged' });
  }
}

This ClientController subscribes to the all method of the AllMessagesService and prints every ChatMessage to the console. It also exposes a /client POST endpoint to receive messages and send them to Memphis broker (through the send method of SendMessageService).

Run nest start to start the NestJS application.

Use any API tester (cURL, Postman, ThunderClient extension on VS Code, etc.) to send a post request to localhost:3000/client. The body of the post request should reflect a valid ChatMessage like:

{
  "author": "UserA",
  "text": "Test Chat Message",
  "time": 1661096069756
}

You should receive an acknowledgement feedback. Check the Memphis UI at localhost:9000, you should notice the sent message (event). Check the NestJS logs and notice that it printed your ChatMessage. Send more POST requests and notice more messages and logs.

The final codebase for FastChat is here on GitHub.

Why did we use Memphis broker?

In a message broker (like Memphis), messages are like events. They are what services use to communicate.

FastChat above is a simple usecase of a message broker. You might not see the essence of producing and consuming messages if this is the only thing you want to build. Besides we placed the two services in the same .proto file. We also implemented both services with the same controller. These were because of simplicity.

In a big project, you will separate your services. They might be in different NestJS projects and deployed from different servers. Yet, they will be communicating via Memphis broker. If you were building a chat infrastructure, other services like notifications, authentication, security, etc. are reasons why you should use Memphis broker.

You will use a Memphis broker because it ensures many-to-many (N:N) communication across your application’s services. It also ensures that every service receives the events or “messages”.

Summary

Memphis broker stands out in its speed and ease-of-use among other message brokers. You can install it with Docker. It has a UI and CLI through which you can manage your projects. You can also manage factories, stations, and users with Memphis broker.

The above FastChat is a simple real-time app to get you started with Memphis broker in NestJS. In summary, to build a real-time app with NestJS and Memphis broker:

• Connect to Memphis broker using the MemphisService and the connection parameters.
• Then produce and consume messages as you need in your application.

Happy Coding!

If we don't give them, how do they get it?

Call-To-Action (CTA)

Consider the CTA as what potential event attendees have to do to indicate interest in the event.

The CTA could be an event registration form. It could be registering for the event on an event website. It could simply be an RSVP. Or in the case of paid events, it would be getting event tickets.

Develop your call-to-action as you start planning the event.

Your CTA will persist across your chosen promotion methods. In other words, RSVP, or "Register", or "Buy Ticket", or what you choose, should be seen anywhere there are details about this upcoming event.

Make the registration process as smooth as possible. This will create a good user experience for those who have an interest in your event while they are registering.

Even if this is a physical event, you can still have ways of engaging people from offline advertisements. You can have people manually registered at some locations or by some chosen persons. You can put phone numbers on banners. Just find a way to dictate potential attendees. Besides, it will help you budget better.

One hidden advantage of your CTA is that it permits you to harvest emails and phone numbers of potential attendees. You can send bulk emails and or SMS to them, for reminders, as the event draws near.

Where affordable (or if it's a great event), you can have an event website. The website could have a countdown to the event, event agenda, promotions content, speakers, about your community, ...

Content

What would they gain if they attend this event?

Answers to that question should be the content of your promotions. Remind prospective attendees about the benefits of being at your event.

Make them feel what they have to lose if they don't take part in the event. You are marketing, so you have to be good at copywriting. If you are not, community members can help. Create good copies and use them everywhere there are details about the event. People will be sold and wouldn't want to miss.

Write in an active voice. Use the pronoun "you". Avoid much text or use bullet points (where possible).

You should have more content for promotions. Stuff like event agenda, about your community, benefits of technologies involved, ... can also be part of promotion content, and not just benefits of being in the event.

However, the benefits should be more than other details.

Graphics (and Videos)

Design flyers or get help for this from core team members.

Good designs tell the viewers the most important things first (have a hierarchy). Good designs breathe (have space). Good designs are attractive and keep the viewer getting all the details (have good branding and color combos).

Flyers should have the event's call-to-action, date and time, venue, content, speakers, title, and logos (where applicable). All those may not fit, or might not even apply to you (you might not have speakers for example).

You can also split what you put in the graphics across other graphics. So that you would have more than one flyer. You will notice that you might end up having a particular event flyer for the whole promotion. That's fine.

It is not mandatory to put (all) the "event benefits" on graphics. Remember that good designs have enough space.

Videos stick more than pictures. Videos show multiple images and add sound, whereas a graphic is just an image at a time. Where achievable, consider having some animation or video for promotional purposes.

Where affordable too, consider using billboards and posters. You might follow this path if your community is large and you have great expectations of attendees. This applies to physical events and is a common choice for paid events too.

Closer to the event day, you can have "countdown" flyers. You can have a "1-week to go" flyer, "3-days to go", etc. They could be consecutive for each day. This is a strategy to engage and remind prospective attendees. Feel free to invent other strategies.

Another way of broadcasting a tech event is by getting community members to share "I will be attending" flyers.

Create a template graphic with space for the attendee's picture and name. Use this template on a service like getdp.co to create a link where people can go and create their "I will be attending flyers". As they share these images, they further create awareness for the event.

Speakers

If you have people coming to share some knowledge at the event, please have flyers for them. Like have flyers that follow your event's flyer template, but this time, with the speaker(s)' images and about them (and what they will talk about).

When you confirm a given speaker, request their details: bio, name, and photo. Use the details for the speaker flyers. Give the speakers their flyers ahead of time and ask them to share.

Most of the time, your speakers are popular and have earned an audience for themselves. Getting them to your event is already promoting your community. The extra step of themselves mentioning that they will speak at the given event is an addition to the event's promotions.

Community

Your community members should be part of the promotions process. Ask them to share flyers and links regularly. Ask them to talk about the event. Make them feel that preparations are steady are going on well so that in turn they will anticipate great things and attend the event.

Have the core-team work on promotions. Delegate tasks. Consider having a promotions committee. This committee will be in charge of everything hype. It could be some core team members. It could be them and some community members too. Preferably choose social people.

The committee might handle everything promotions from beginning to end. Just devise a way to follow up and be sure work is being done. Set goals, targets, and timelines.

Leverage other social gatherings in your locality. For example, make announcements for the event in religious gatherings, sports/club activities, other tech communities (and their events), ...

The core team and community members should follow suit. If they are in any place where they could share about the event, please get them to do so.

It's fine to collaborate with other communities for tech events. The collaboration helps with promotions too. It is mutual leverage worth mentioning. Both parties tell the people about each other, so yes.

Social Media

Your community should have social media platforms you use already. Post regularly on these platforms about the upcoming event. Use engaging captions when posting the images.

Have a hashtag (if you deem it fit). It could be a peculiar hashtag for the event or a hashtag your community always uses.

Tag and post the speakers.

There might already be core team members handling the community's social media. They should continue and just up the game. The promotions committee can also help. A content calendar is in place. Use tools with scheduled posts if you know how it works.

Where affordable, reach out to influencers and get them to share and talk about your event. You can use online or local influencers depending on where you host your event.

Where affordable, use paid digital marketing. That is pay social media platforms to advertise your event too. You will also get potential attendees from there.

Summary

Promotion is marketing and is not an easy task. If you plan well, you will get it right.

It is okay if you exhaustively promote your event and the attendee count on the event day is low. On average, the conversion rate of advertisements is about 4%. So if you have a greater than 4% of your RSVPs attended your event then you should be proud of yourself.

With regards to your event and the entire marketing, remember the following:

Do not over promise and do not under deliver.

Generally, physical events are more demanding to plan than online events. We need more efforts to gather people in one place compared to getting people to join an online event.s

Either way, don't just start hosting the event. First, plan it.

Please, PLAN!

Proper Planning Prevents Poor Performance

The importance of planning can't be overemphasized. Many community events don't turn out well because of no planning or because the planning could be better. Yes, there are event dynamics and some things might not turn out as expected. But for the many variables you can control, please plan effectively to ensure a good event.

Planning is like being in the event before it happens. Because in most cases, as your event is taking place, you might not have the chance to follow up with the event as attendees are. At event time, you would be busy with ensuring that the next agenda is ready.

With planning, you take note of various parts of your event. Check that each section has been prepared. And possibly have a backup in case some inevitable failures happen (like speaker absence).

Event Purpose

Don't host events because events are hostable.

Define what you want to achieve with the event you are organizing. What impact do you want to make? What awareness do you want to create? What do you want attendees to learn newly?

Clearly define your objective(s) for the event. You might be growing a tech community and you are following your already set event calendar. If you don't have such a calendar, you still need to state what impact you want the event to have after it must have taken place.

Event purposes could include (but are not limited to):

• Explaining how to go about a particular task (like contributing to the community, for example.

• Inspiring community members to consider a particular technology.

• Motivating attendees to keep up with learning.

• Showcasing what community members have built.

• Teaching a particular programming language, skill, or technology to attendees.

• ...

Date, Time, and Venue.

Date

Please choose a date at least two weeks or a month away from when you start promoting your event.

Please read that again. It is not at least two weeks from now. It is two weeks from when you start promoting.

The reason is for community members to adjust their schedules and prepare to attend the event. People are busy and they already have what they want to achieve in the nearest future.

If you schedule an event within three days, the attendee count won't be as optimum as it would have been if you had been announcing the event for two weeks or more.

A month might be small for announcing your event if you have a big community or if you are expecting a large number of attendees (like DevFest).

The specific day of the week where you choose your event depends on you, your community members, and expected attendees and guests. You might want to have your events on weekends since, during the week, people might be busy with school or work (especially if you are planning a physical event).

You can also deliberate the date choice with your core team and or community members. Such deliberations are preferable, especially with the team, because they will help with carrying out demanding tasks during the event, which you alone cannot do. So their opinions greatly matter.

Sometimes, if you target peculiar speaker(s), reaching out to them first to confirm their availability might be necessary before scheduling a date. This is especially if that particular speaker is a busy or an important person.

Two weeks or more preps for an event might be too much if you have this event in regular intervals (like weekly for example) or if it is a closed event (just for a few persons to attend).

Time

So you've picked a particular day. Up next, you have to choose the time.

Mornings or during the day is preferable if it is a physical event. As such people can come from different places and go back before night time. Tech events that occur at night are rare. In most cases, such events will span multiple days.

If you are hosting a physical event in the morning, consider setting the time to be late morning, maybe 10 AM, or towards noon. This is for you and team members to have enough time to set up the venue that morning.

For online events, the preferred time is more liberal. Some communities prefer having their online events in the evening or night times because by then, everyone would be comfortable at home to stream the event. So there is no one-fits-all recommendation.

Besides, we can't compare event timing for virtual events with in-person events. Virtual events usually last for a short while. There is not much chitchat. Agendas are straight to the point (max of 2 hours or less on average).

With physical events, agendas are usually long. Plenty of engaging and fun activities make time to pass without being noticed. (Making morning preferable).

As with the date, choose event time with the core team and or community members too. It is community stuff so people's opinions should influence decisions.

Your speaker(s)'s availability might also affect event timing.

Venue

For online events

Pick a platform that your community members are comfortable with.

Recording availability and attendee control are features that could influence your choice of video conferencing platform too. Attendee control means removing or muting attendees who spam or distract the online call. You might want to keep event recording for those who missed the event to catch up. Also, the recordings serve as a track record of your community's activities.

Google Meet doesn't permit recording nor does it give you control over attendees in the free tier. You would need to pay for Google Workspace to have those features. Google Meet, however, doesn't place limits over how long the call can happen.

Microsoft Teams is free for up to 60 minutes and 100 participants and natively supports recording.

Zoom permits recording and gives you great control over attendees. But on the free tier, your event can only hold for 40 minutes. Participants will have to join back again immediately with the event link, after 40 minutes elapse.

Messenger Rooms and Telegram Video chat are also great platforms for video conferencing. But with these platforms, recording is not supported natively. You will have to record your screen while the online event is ongoing.

You have many other options to pick from.

You might not need to make a platform choice because your organization already has a platform for itself. For example, it makes sense that Google-related communities use Google Meet (or Bevy), Microsoft Learn Student Communities use Microsoft Teams, Facebook Developer Circles use Messenger Rooms, ...

Talking about the free tiers of various video conferencing platforms is crucial because we are talking about community. It is all volunteer and we might need it as free as possible given that the event could equally be free.

If however, you have access to paid event platforms, or you can pay for the features, or you have sponsors for them, please don't hesitate to enjoy what you have.

Twitter Spaces is another viable option but it is audio-only and may not give you the opportunity to present slides. Youtube Live is another good option, especially if the event is for a large audience. But remember, people can't interact with voices.

For physical events

Venues for physical events are hard to get. First, they might not be free. Secondly, they might involve protocols to book a peculiar date.

You may not need to pay for a venue if the event is happening in an academic environment. So you can leverage classrooms, school buildings, or university auditoriums.

If the tech community is not student-centered, you could leverage buildings in religious places (like church or mosque halls) as those may need little or no cost.

Tech hubs in your locality are also places you can choose for your event. Though you might have to pay. You can also collaborate with them and use their hub for free.

Paying for venues should technically not be an issue. You will get event sponsors. Besides adding a little ticket fee to cover up crucial event expenses like the venue is very okay.

Your hall choice depends on the event. You have a rough estimate of your community's population. You would choose a venue whose capacity is close to this rough estimate. You can't be going for an extremely large hall when your community's size is 20% of that hall's capacity. Likewise, going for a 50-capacity hall when you have a population of about 300 people doesn't make sense either.

You can also check if the venue has a stage where speakers can stand and face the audience. The control of hall lighting affects the visibility of projected slides. So consider that too. If you are rather hosting a workshop and members need to be in clusters, you technically do not need a stage for your event.

At times, you might choose to host the event in the form of an outdoor happening. So you look for lawns or parks in your locality and use them for your event. Such events could fit demo days where the public's attention is captured. It could also be a get-together after some long-term intensive learning or a picnic to meet and greet with other communities.

Factors affecting venue choice are vast.

You will definitely choose one venue for one event.

With in-person events, you might end up using the same venue for many events. Simply because your community is already known for that particular venue and you all are comfortable with the place.

The event venue is another reason why you should schedule your events very well on time. The reason is you want to be sure that you don't have clashes on that venue for another event by another program that might have been scheduled before you. In fact, you should follow up on your event venue as the event approaches to ensure that you won't have venue issues on D-day.

Event Agenda

Agenda is the chronological order for programs during an event with the estimated for each program.

Preparing your event agenda should be done close to (if not at) the same time that the event was scheduled.

From your event purpose, you already know the core programs you want to host. Maybe a speaker session, a codelab, some presentations, ...

This should take most of the time in your event agenda. Other programs are welcomed but they should not exceed the event's core programs.

You should showcase your agenda way before the event while promoting the event or on the event website (if you have one). Showcasing might entail just mentioning the core programs, not necessarily every detail.

Such agenda showcase partly encourages event attendance. Attendees already know what to expect during the event. They would be willing to attend given that they are sure that their time won't be wasted.

Showcasing also makes you and the team accountable. If during the event things don't go as planned, and the degree of parity is much, everyone will definitely be unhappy. Besides the event agenda helps you develop a checklist for the event that will guide your planning.

Social media breaks and or taking pictures should be part of your agenda. Please don't forget. Ask attendees to post or tweet about the event. This helps with promoting your community.

You can also incorporate games, giveaways, trivia, quizzes, slidos, kahoots, etc. to make the event fun.

Following are three example agendas

1. Example Agenda for an online speaker session

• Welcome Delay/Introduce Speaker: 5 mins

• The speaker speaks on the chosen topic: 20 mins

• Questions: 5 mins

• Short Trivia: 5 mins

2. Example Agenda for a physical workshop

• Welcome & Networking: 15 mins

• Codelab part 1: 1 hour

• Short game break: 10 mins

• Codelab part 2: 30 mins

• Questions: 15 mins

• Pictures/Social Media Break: 10 mins

• Refreshments/Close: 10 mins

3. Example Agenda for an online hackathon

• Hackathon announced: 10 mins

• Competitions take place: 1hr 30mins

• Short speaker session: 15 mins

• Winners announced and awarded: 5 mins

• Giveaway session: 5 mins

Event Content and Slides

Curate content and prepare slides as you plan the event. You shouldn't do this very close to the event date. You should prepare and get others to review them early enough to have time for other preparations.

You can delegate the preparation of your event's content to someone in the team or community. Then crosscheck and improve the work when they are done.

You might not need slides for some events, for example, if the event is an outdoor gaming session. You might not also need to prepare any content if the speaker will prepare their slides.

Yes if you have speakers, their slides should be ready. Whether you, them or whoever prepares their slides, their slides should be available. This partly confirms their commitment to being available during the event day.

Event content could be codelabs or step-by-step procedures to be used during the study jams or workshops. Event content and slide should be of quality. You are planning a great event, so let everything about it be great too.

It might not be hard to prepare the slides given that you might already have some slide templates for your community. So you just make a copy and get it edited for each event. You can also share the template with the speaker to use to prepare the content.

A popular slide management mechanism is to have just one slide for an event that will have every program in it. Then you add the speaker(s) to the slide so that they could edit the part they handle in that slide. As such event content is centralized and projection or sharing of slides can be done from the same place.

Speakers

If need be.

Get them if you need them. Get them ahead of time.

They are people with their own schedules, so reaching out to potential speakers and blocking their calendars early enough are must-do if you need them.

In our online world, speakers are easy to get. They could be anywhere in the world and join your online event. That's great.

With physical events, speakers would have to migrate and possibly sleep, in order to be part of the event. This might be easy if this is a huge (and maybe paid) event where the speaker's expenses are possibly sponsored. And might not make sense if it is for a small community event.

You might want to use community members as speakers. Yes, give them the opportunity to grow. It might be their first time addressing a crowd and they may learn secrets of public speaking from there. After all, that is why it is a community. Everybody gets an opportunity.

To be sure that speakers are preparing for the event, you may want to place a deadline on when to submit event slides. Maybe a week or 3 days before the event. Review the slides and give them feedback. This helps to keep event content with community guidelines. You can delegate this task to someone on the team or a volunteer.

Rehearsals

Especially for online events.

Consider scheduling a mini-rehearsal with the speaker(s) and moderators and be sure that everyone on stage is comfortable with their roles.

If your event involves presentations by community members (like on a demo day), then the presenters should also rehearse before time to ensure an optimum presentation.

Collaborations and Partnerships

If need be.

These are not mandatory. Without collaborating, you will still organize good events.

Collaborations are working together with other tech communities around to pull an event. Collaborations come with many advantages. You learn from each other. You get to achieve more as there are more heads and hands working towards the success of the event.

When collaborating, contributions should be well-defined. This is crucial to successful collaborations, or else one party ends up being stressed by the collaboration.

Not only two communities can come together. 3 or more can join hands too. However, the more the number, the harder the control.

Tech communities each have their branding. When partnering with others for an event or a program, flyers or graphics for that event will include brand logos/colors of the involved communities. Have this in mind when mixing up.

Also, each community has its policies and code of conduct. So respect each other and avoid crossing boundaries.

That said:

If you want to go fast, work alone. But if you want to go far, work with others.

Promotions

This is the most demanding part of planning. It is a continuous process in itself and you will keep promoting the event even till the event date.

In general, you will have some call-to-action. Probably a form or a website where people can RSVP for the event. You can harvest emails and or phone numbers to send reminders as the event approaches.

Graphics and social media will greatly help you to promote your events too. Setting up a subteam just for promotions is another common practice. Community members can equally share the event regularly.

Visit here for more info on how to promote a tech community event.

Photography

If this is a physical event, then you should take pictures during that event.

The pictures serve as social proof. Your community can also use it for its promotions or when advertising for the next event.

Photography is serious business. Depending on how your event is unfolding, you will either get a volunteer to snap pictures with a phone in the event OR you will hire a photographer(s) to snap (and record) sessions.

Photography is more serious if you want to stream the event. You will need a complete setup for media-related stuff and switching. At the bridge you will cross it. Just plan for photography too if you need it.

You can find photographers in your locality nearby or by searching online or by asking around. If they are expensive or you don't really need them, you can also check your community members for those who have cameras and could volunteer for photography during the event.

If you are serious with photography, then you could have a big backdrop for pictures. This backdrop could be somewhere around the venue's entrance. The backdrop usually contains logos of event sponsors.

So equally plan on getting the backdrop towards your event date. Design and print it ahead of the event or delegate this task and check up on the person to do it later on.

If this is an online event, screenshots or recordings of the event could suffice.

Conclusion

Remember, please PLAN your event.

There is no guarantee that all you prepare will happen exactly as you planned. Many things change with time and unforeseen circumstances can easily arise. But if you adequately plan your event, it will be a successful one, and you will be a step closer to achieving your goals.

Cheers!

Reasons why you should grow a tech community?

Growing or starting a tech community is a demanding task. In most (if not all) cases, this task is a volunteer one. In other words, you are not paid for the leadership service. Notwithstanding, the following are reasons why you should grow a tech community.

A. Experience

You will become a leader. You will plan and host events. You will network with high-profile experts in the tech space. Community building will boost your portfolio, after all, it is a skill in itself.

B. Passion

Grow a tech community because you want to mentor people (where you can). You want to help people by providing them access to information and tools they otherwise wouldn't have known about.

As you grow or build the community, you bring experts and beginners together. As such because of the community you are maintaining, beginners will have a chance to be mentored by others not necessarily you.

C. Social Capital

You have impacted people's lives. Hence, you are part of their stories. In turn, they help you where they can. They begin to wish well for you.

You gradually become a public figure. People will value your presence at events and would like you to be their speaker. You must have made a great number of quality friends that will be there to support you when in need.

From scratch or taking the baton?

In growing a community, you either start from scratch (building a community where there was none) or continue the mantle from some previous community lead.

The difference

If you are starting a new community, you will either start one out of passion on your own (and become its founder), or you start one under the umbrella of existing tech companies/communities (starting a new chapter of community programs like GDG, GDSC, Facebook Developer Circles, etc.).

If this is your case, you might have more work to do. You will have to promote the community aggressively and be very welcoming in order to get active members. Don't fret. It is possible. Existing communities were once never there and were built by someone, so you can do it too.

If on the other hand, you just continued leadership from a previous lead, your job is to maintain an existing community. Chances are there are already active community members that can help you, so your job will be easier. You however should not take such an opportunity for granted else you will fail to grow that community.

What's similar?

In either case, you are in charge. You are looked up to as a model to be followed. You make core decisions about how things work in the community. You give instructions that others follow.

How to Grow a Tech Community

1. Goals

Set goals. Work towards your goals. Strive to achieve them.

Failing to plan is planning to fail.

Measure

Take statistics of the current community's state. Take note of metrics like the number of members, how active are the members, are the members growing, their technical expertise, what they want to learn, ...

Note that this might not apply to you if you are building from scratch. If this is your case, look around for a starting point, you will notice pointers that will guide you.

Plan

Draw up a plan of things you want to see in your community after a period of time (maybe in a month, 3 months, 6 months, ...).

This will give you insights into how you should proceed. Set a calendar for events you will organize. The event types you will organize and the intervals between your events depend on what you want to achieve.

Analyze

Measure performance and progress. Check weekly for what was better or worse. Adapt your strategy toward your long-term wishes and goals for the community. Ensure that before your tenure ends, you must have maintained the community and made it better.

2. Team Work

TEAM: Together Everybody Achieves More.

You can't do everything alone. You need to work with people. After all, chances are you are volunteering. So call for volunteers too and create a core team as you need.

Split tasks and delegate them to the core team or community members. Motivate and reward volunteers and active members, this will make them do better when next you give them a task.

You are the lead, yes! But please it is a community. Don't be authoritative. Don't impose only your wishes. As you work with others, seek their opinions and allow them to execute their wishes. Carry people along and let them know what you want to achieve.

Communicate frequently and in detail. This way, you are sure there is proper context among everyone. Encourage community members to contribute in different ways. Remind them that their active participation keeps the community alive.

3. Events

This can't be overemphasized. Organize and promote events. You have to do this to keep the community alive.

You can organize different types of events like speaker sessions, demo days, bootcamps, ... Just plan your event well ahead of time and everything will fall in place.

Also partner with other tech communities around (where possible). Be open to working with people. Look for sponsors and accept collaborations. Your events will be blasts and become a remarkable person.

4. Promotions

Hype your community and its events. Use social media and other advertising at your reach. Let the world know that such communities exist.

As you promote the community, more people get to know about it and more interactions with it take place.

5. Policies

Always communicate the community's Code of Conduct to new members. Once in a while, talk about them to your old community members. This keeps everyone in check and reduces the chances of defaulters.

You are doing a great job and people will support and help you as you grow the community. So don't feel afraid to do the job.

Cheers to your success in growing your tech community.

We are talking of huge benefits that you won't easily find in other places.

Tech communities are places where you find other techies like you. While there, you will enjoy many advantages.

Below are 5 examples of such gains.

(They are in alphabetical order).

1. Growth

You will never be the same again.

You can read that again and again for yourself. Rest assured that once you are actively participating in your community, you will grow.

Progress is something you will continuously record while in the community.

As you interact with people, you learn from them and discover better patterns of doing several things. You will notice the difference in yourself over time and will appreciate the fact that you are involved with a tech community.

Track your abilities and achievements now. Contribute to your tech community. Check your abilities and achievements after a period of time. Then admire how much you have grown.

2. Experience

There is so much to do in tech communities. On a frequent basis, you can code, design, lead, speak, write, ... for your community.

Then on unique chances, when events are organized, you can do other things for the community towards the events' preparations and execution. Such things include preparing slides, preparing the venue, promoting the event, searching for collaborations, sourcing speakers, ...

All these things are of course volunteer activities. By doing them, you can boast of the experience that comes with them. You can also include such volunteer experiences in your LinkedIn profile.

You can tell your community activity stories on online platforms (blogs and social media). This will build your online presence. People will quickly know your abilities once they land on your online profiles.

During job interviews, you can narrate how you worked in the community, the problems you faced, and how you solved them. Such will easily grant you the job in question.

You will value working in the community because it gives you a platform to act freely. There is no boss to command or sack you. You have the opportunity to work in teams of great minds. You will gain insights into how corporate things are done (for free).

You will especially value your community experiences if you've never had any professional experience before. Even if you have formally worked, adding community to the list is still a boost.

You will gain experience.

3. Exposure

You will be exposed to diversity. You will be capable of networking with others in the community.

You will learn from different technologies. You will have a great overview of various digital skills, programming aspects, and software tools, just because you are in the community.

In fact, you will learn about other cultures and will understand how people think.

People will know you and will refer you for your skills when needed. You will be nominated for jobs because you are part of the community. You enjoy free marketing.

Exposure is also for your online presence. Your social media activity and followers will grow too. If you are a content creator, you have automatic leverage for exposure.

4. Mentorship

Tech communities comprise persons with various levels of expertise. Beginners, intermediates, and pros are found in the community.

In this space, people with different experiences share their stories. They will tell you the things they did that worked for them. They will tell you what you should avoid out of their experiences.

Mentorship is priceless. You grow faster when you appropriately follow mentors. The journey will be smooth.

Mentorship is one thing we find in tech communities that make communities thrive.

The best part? You gain mentorship. And when you become that good. You become a mentor too. And you can give back to the community.

5. Swags

SWAG: Something We All (Don't) Get

We all sincerely can get swags because it is not easy to make a great number available for all community members.

Either way, swags are branded items shared with community members.

They could be caps, mugs, polos, pens, stickers, ...

Swags are a cool way to brag that you are part of the community. Designing your laptop and other assets with stickers makes them look prettier.

Swags too help with promoting the community. People get to know that such communities exist when they inquire about the brands, designs, or logos, attached to swags.

Aside from swags, you can also win prizes for participating in competitions, giveaways, and hackathons.

There are many other benefits of being part of a tech community.

However, you will gain these and other benefits on the condition that you are an active member. You need to follow up and be part of the process. Attend events, be part of conversations, and join other activities.

Remember to keep to your community's code of conduct.

Cheers to your many community gains.

Give back to the community.

The active participation of community members is the fuel that fires the life of a given tech community.

To contribute to a tech community, provide volunteer assistance where you can. You can do something that will help others.

Below are examples of ways to contribute to a tech community.

(They are in alphabetical order).

1. Coding

Programming is the building block of all software.

Many communities have open-source projects. Usage of Free and Open Source Software keeps increasing by the day. Open Source needs more coding hands for innovation and maintenance.

Coding is one way to help the community. At times, you might be involved in coding for hackathons (competitions), aimed at building real-world solutions for your local community. It is still a way to contribute.

If you are a good programmer, you can help grow the community by doing what you already know how to do well, coding.

2. Communicating

Communication is underrated.

Communication accounts for a greater part of a team's success.

Communication in a team should be detailed and very often. The details help context and the frequency ensures that everybody is at the same pace.

In your community, you can actively communicate about events, community projects, or local happenings. You can discuss your problems, progress, or what you want to achieve.

You can also get involved in discussing others, where need be. Just ensure you stick to community guidelines, and that you interact in ways that do not discriminate against others.

When communication slows down or gets absent in a community, the community gradually dies. People lose vibes and get bored.

Communicating ensures that your beautiful community remains alive. Actively communicating is something every community member should at least do.

3. Designing

To design is to plan

There are different types of designs. For example Graphics Design, Product Design, UI/UX Design, ...

You can contribute to the community by designing event flyers or banners. In turn, people get to notice your nice designs and could reach out to you for jobs.

You can also get involved in the design process of apps or products that your community could build.

When things are not designed (are not planned), they don't turn out well. Your designs can save the day (and the community as a whole) if only you design them. Please assist your community today by designing where you can.

4. Leading

Most tech communities start with a lead or an ambassador who organizes the community.

Anyone can take this role. Especially if you are good at people management and you can be patient with people.

Leading is naturally rewarding because the persons you lead will be loyal to you (that is if you are a good leader).

If you are not all that social, or you don't have leadership experience, tech communities give you a good platform to get good at that. You could be a team lead or a tech community lead.

Consider maintaining your tech community by being available for leadership when the need calls (leads are not always needed).

5. Mentoring

Now you have learned a skill. You are well-known in that domain. Your opinion strongly matters when questions arise on the subject.

Guide persons who need help.

There is love in sharing.

Don't keep it all to yourself. After all,

You learn better when you teach!

Tell your story. Let them know what they should avoid doing so things will be easier for them.

Mentor community members so that their growth will be a smooth one.

6. Promoting

Hype is necessary. In fact, in every community event, there should be a social media break. Attendees should post/tweet with some hashtags for the community or the event.

Improve the community by telling people about it. Invite persons to upcoming community events. Tell people about community programs. (Unfortunately, many don't know that these programs exist).

The more a tech community is known, the more its members, and hence the more its growth.

Be influential. Share about your tech community. Make it popular.

7. Speaking

On average, we speak more than 5000 words a day.

Speaking here is not day-to-day interactions. Speaking here refers to Speaker Sessions. Events where you are on stage talking to others. (The stage could be virtual: virtual events).

If you are well-informed on a given subject, you can speak on it at an event.

If you are not versed in that topic, you can still do some good research and rehearse before the event day.

Speaking requires you to keep the audience engaged. You should be interesting. You should inform and marvel your audience.

Speaking is learnable. Everything is learnable. Whatever!

Speaking at community events is one way to contribute.

8. Support

Stackoverflow is underrated.

It is a community where programmers just support others.

Sometimes you just get stuck at some logic flow or implementation detail and you need help. You might need help with other things, not necessarily programming. Maybe laptop repairs, or how to use software, ...

Supporting people is one of the main features of most, if not all tech communities. We help each other and sort out problems. We learn and then grow from there too.

Please don't hesitate to offer support where you can. And please be kind when helping. The person being helped doesn't know their way out, that is why they asked in the first place.

9. Volunteering

Everything on this list is volunteer stuff.

It makes sense that everything community is volunteer-based. If there were payrolls, how would they be arranged around the different things community members do? Not only do leads deserve rewards, every other person does.

See the volunteering as some sort of advocacy for digital stuff. That people, should be moved towards doing things freely. After all, they will equally obtain things for free.

Community events are usually free. When they are ticketed with some price, the price is to keep up with the expenses. Tech Communities are not for profits.

Volunteering shows up everywhere in the community. Most especially, organizing events requires a great deal of volunteering. For example, getting speakers, preparing event venues, promoting the event, etc. are ways you can volunteer in your tech community.

10. Writing

Documentations are life-savers. Many times, programmers didn't document the code and the docs will have to be created. Writing docs also need some level of content development or technical writing.

You can contribute to your tech community by writing documentation for community-built projects. The docs could be doc comments or docs and examples of a docs site on its own. Of course, documenting will require that you understand the product being documented.

Writing could also be for articles just like this one. You could publish books too. Anyone can write and everyone should write. Because we spend the greater part of our time reading anytime we are on our screens. So yes, write.

Please contribute to your Tech Community, in any of the above or more ways. Thanks for reaching here.

Events are happenings. Community events are moments of bonding and celebration. They are a means through which others out there get to know about the tech community in question.

Community leads/organizers together with the core team plan and execute community events. They announce the events ahead of time to get a good number of attendees. Events have an aim. They could be technical, inspirational, for entertainment purposes, etc.

Based on Location

Community Events are either physical or virtual, based mainly on where the event takes place.

Physical Events

There will be a live/physical location where attendees meet for the event. Attendees get to meet other community members face-to-face, spend all the time, and make new friends. The events usually take place for over hours or a whole day.

During in-person/physical events, attendees could receive swags or eat food or snacks.

Physical events are in most cases organized by local communities. That is communities within a school campus or a town or city.

In rare large-scale cases, there are also community events that could have a large number of attendees. These huge events are usually organized by popular tech brands. Like OSCAFest by Open Source Community Africa, Google I/O, Facebook F8, etc.

Physical events were very popular till the COVID pandemic when people could not meet physically for health reasons. As a result, the number of hosted physical events has drastically gone down since 2020.

Virtual Events

Online events take place over video conferencing platforms like Google Meet, Messenger Rooms, Microsoft Teams, Telegram Calls, Zoom, ... Anybody anywhere can join these events as there is no constraint of physical location or transport cost.

Virtual events are common with large online communities, given that people join in from anywhere. Most virtual events take place for a short period of time: an hour, two, or rarely three hours.

Virtual events or webinars are very popular now as a result of the COVID pandemic.

Hybrid Events

This is an uncommon mixture of both physical and virtual properties of an event at the same time.

So people can meet physically in a given location, but then the event could be live-streamed for others to have access. Another format of this mixture is that people who can't be at the venue can join the event virtually through video conferencing, but then there will be some main device capturing the physical event.

Hybrid events are also seen in cases where speakers and event attendees could be in far different locations. So the speaker(s) could join through video conferencing, while the attendees listen. It is also common to host watch parties. In that case, an event is been live-streamed for people who met physically.

Based on Aim/Agenda/Format

The aim of an event determines the agenda or format of the event. The event's aim also determines its activities and venue. Events can be split into different types based on how the event proceeds and its aims.

All the following event types could either be physical or virtual.

0. Meetups

This is the common name for events by tech communities. You will hear the word "meetup" several times in community spaces (especially in-person/physical communities).

At a basic level, all community events are meetups because as the name implies, it's just people "meeting" together.

Meetups are commonly used to gather community members on some periodic bases (weekly, monthly, every two weeks, ...). Meetups take different structures depending on the current goals of the tech community in question, or the choices of the lead/core team.

1. Info Sessions

These are kind of introductory meetups. They are commonly used for awareness. An info session is kind of a launch event.

Info sessions are like announcing that a new chapter of a tech community is just beginning. A newly appointed community lead can host an info session to start a community or to continue an existing community while communicating their goals for their tenure.

Info sessions could also be used to introduce bootcamps or competitions.

As the name implies, info sessions are aimed at informing attendees. The agenda could involve demos, games, speakers speaking, or whatever the core team decides. The event would be aimed at engaging the members for whatever would be coming next.

Generally, it is not common to see info sessions being held.

2. Speaker Sessions

Very popular. The model is simple, some speaker(s) speaks to the audience. Speakers usually inform the audience about some rare-to-find secrets or inspire them to take some action in their career paths.

Whether physical or virtual, speaker sessions usually have a presentation of slides. Slides visually help the audience to understand what the speaker is saying. Slides contain text and sometimes graphics that the audience could refer to after the event, to remember things the speaker said.

Speaker sessions are usually on career topics or soft skills. These events educate community members on things that are rarely found in tutorials (like collaborating, getting jobs, personal branding, ...).

Speaker sessions are not quite interactive given that there is a speaker on stage. The event might incorporate a little game to drive activity from attendees. In speaker sessions, attendees can ask questions to the speaker(s) towards the end of their session to clarify ideas or opinions.

3. Study Jams/Hands-on Workshops

This is where technology meets community members. These are events where community members learn a technology or acquire some skills.

Study Jams are events where community members are clustered in study groups. In these groups, members learn stuff and improve themselves from resources provided by the community.

Workshops are interactive mentor-led study sessions. The mentors outline step-by-step instructions that community members are to follow. Then as the community members follow these instructions, they learn the needful. The mentors could check learners' work and help remove any blockers they may experience.

Study Jams and Workshops enable community members to practically get better at some skill/technology. It could be cloud computing, technical writing, user interface design, ...

These events broaden the knowledge of its participants. Should in case participants in the future do not want to follow the peculiar skill path being learned, they would have understood the basics of that skill/technology.

4. Hackathons

From:

HACKing marATHON

Hacking is about exploiting vulnerabilities. Marathons are about speed. Hackathons are about coding competitions.

Hackathons could be open for days/weeks or could take place just in a day. They are an avenue in which developers can showcase how far they've gone in their skills.

Hackathons are competitions and competitions have prices. Winners of hackathons always go with their rewards. In fact, the rewards are announced before the hackathon starts. This motivates participants to compete.

Hackathons take different formats. At times, they could require competitors to build some big project over time in a team, or they could require them to complete a small task quickly while being timed (alone).

Hackathons are fun events that boost winners' self-esteem. Participate in any upcoming hackathons near you.

5. Bootcamps

These are intensive learning events. They span for weeks or months. Bootcamps are a series of events where community members learn skills together.

Unlike study jams or workshops, bootcamps are not one-time events. However, bootcamps could incorporate them at various intervals. Bootcamps could also have meetups or speaker sessions in between the series.

In most cases, participants of bootcamps build projects towards the end of the bootcamp. The built project proves that the participant is actually graduating with the acquired skill.

Furthermore, most communities open participation in bootcamps to the public. That is other persons who are not community members are allowed to participate.

#30DaysOfCode, #10DaysOfDesign, ... could easily be organized as bootcamp programs.

6. Demo Days

A demo day is an event where community members showcase to the public what software they had built.

It is not easy to build projects. Displaying what you built is one way of being rewarded for building. After community members have built some solutions or created innovative apps, they could deploy them. Then on the demo day, they can showcase these digital products to the public.

Demo days are parties. They are usually climax points in the life of a tech community. Sometimes, bootcamps could end in a demo day. This makes sense since bootcamp participants could showcase what they built in the bootcamp during the demo day.

Demo days are like an accountability system to the community. In itself, a demo day passes the message that within a given tech community, the members are building projects, which is one of the aims of tech communities.

Demo days rarely take place because it is not easy to complete projects worth showcasing very frequently.

7. Brand Events

• DevFests
• GDSC Solution Challenge
• Microsft Imagine Cup
• ...

These events can't fall in the general categories above. They are most of the time, annual events. These events are inspired by some goals (like being innovative or solving problems). They could also be in the form of competitions and have their rewards. They are maintained by the tech companies bringing the peculiar community.

Attend Events

As you read, there must be at least one tech community event going on somewhere in the world. This is because there are so many tech communities out there. Community events make tech communities lively. They are interesting gatherings and you would always want to attend them after attending your first community events. Go out there, take part in as many community events as possible, and enjoy your stay in your tech community.

A tech community is a family of people who love digital stuff. It is a group of persons with digital skills (like programming, designing, content creation, etc.)

These communities are a space for techie persons to get help and help others. It is there that they express their techie lifestyles. They also brainstorm solutions to problems and build products (software) together.

Members of tech communities usually have day-to-day interactions across various social media and messaging platforms. Such communication among members keeps the community alive.

There are also tech events in which these interactions are usually at their max. Community leads usually organize these events for the community. These events could include speaker sessions, meetups, hands-on workshops, competitions, demo days, and others.

One important thing we find in communities is mentorship. The community brings professionals and newbies together. As such these pros can guide the starters in their journey.

A mentor is someone who has had experience in a particular path and would guide their mentee on that path and ensure that this mentee avoids the mistakes the mentor made.

Tech communities also keep the zeal around techie lifestyles alive. It feels good to have people of like minds around you; people with whom you have engaging conversations; people with whom you can collaborate on projects; people that help you solve problems.

Community members contribute in different ways and hence the community grows. Of course, they gain various benefits from being part of the community.

Structure

Lead/Ambassador

There is usually some person in charge of a given community. Different tech communities give this person different names. Names could be lead, ambassador, organizer, head, president, ... Irrespective of the name, this person oversees the activities of the community.

Community leads organize the events of that community. They oversee, control, and preside over the activities of the community.

Sometimes, there are two co-leads heading the community. Being two of them, the chances of mistakes are lower. Support is better and one can complement another's faults. After all,

Two heads are better than one

Community Leads are volunteers. They are not being paid for their work of bringing the community together. Of course, the efforts are worth it. Leads gain leadership experience they can add to their portfolio. They also have access to networks of other community leads themselves.

Core Team

A group of persons in the community with different functions towards the maintenance of the community.

The Core Team is usually instituted by the community lead. It comprises volunteer community members that have various roles. These roles could include technical leads, graphics designers, mentors, social media managers, promoters, and public relations officers, among others.

Community leads can't manage the community all alone. They need assistance from core team members. The core team members take care of various departments of the community and report to the community lead.

Core Team members are invaluable. They help in event planning and execution. Together with the lead, they make community events worth attending.

Community Members

If there were no members, there would be no community. In fact, the lead and core team members are still community members.

The community members attend the community events, participate in competitions/workshops, contribute to projects, and support each other.

As the community grows, the community members increase in number. The reason being more people are taking note of the community and are willing to join. Community members themselves invite their friends/colleagues to the community and so yes the community grows.

Code of Conduct

All communities have guidelines.

Community members come from different backgrounds. Tech communities have the widest diversities so far. In this space, you see persons with different religions, different political views, different races, accents, languages, ...

For the community to thrive, members have to stick to the community guidelines. Sticking to the guidelines makes the community inclusive. In other words, it keeps people from different backgrounds welcome.

The aim of tech communities is to provide a safe space where people can grow in their tech journey. As a result, we need to be sure that discrimination or bias are nowhere near communities.

In most cases, the code of conduct will involve the following:

• Communicating constructively.

• Not discriminating.

• Being kind, empathic, contributing, supporting,

• ...

We strongly hate all kinds of discrimination, whether based on religion, race, sexuality, ... When interacting, ensure you don't speak in a way that attacks someone's personality.

Members who violate community rules are usually reprimanded or asked to leave (if they don't change).

In Summary ...

Tech communities are spaces where beginners become proficient, members help each other grow in their tech journey, and techies have a lifestyle. Leads and core team members maintain the community. The support system is from the community members themselves. To keep the community as inclusive and as diverse as possible, everyone has to stick to the community guidelines.

Join a tech community in your locality today and watch yourself grow. If you are already a community member, participate actively and give back to the community.