Skip to main content

GSoC Ideas

Deprecated​

The ideas on this page are deprecated and will not be pursued.

Deprecated

Introduction​

Welcome to our ideas page! Get familiar with our general philosophy by reading this section. The ideas follow afterwards.

General Considerations​

This is not an exhaustive list of ideas, but they broadly classify the types of features on which we'd like to focus our attentions.

You are open to propose your own solutions.

  1. We encourage candidates to think laterally.
  2. Take the initiative and consider something hybrid taking thoughts from various ideas posted here or something totally new.

We want ideas that will have a material impact on the project

Remember, the ideas list is just a guide for what we feel could be achieved, and not a strict list of requirements. Think of the overall goal of making a better product. Picking a subset of suggestions and expanding them beyond our expectations shows your initiative.

NOTE: If you feel the project ideas will take too much time as stated, then:

  1. Add that to your proposal
  2. Include what you think a reasonable scope should be.

We need your ideas to be completed on time with 100% test cases with each PR.

  1. Brittle code that breaks easily does not help the project
  2. Incomplete functionality is not acceptable unless specifically stated.

If there are any dependencies on other project ideas, then state it. Also include additional or alternative things that you would do if the dependencies are not completed in your desired time frame

The project is so much in its infancy that we'll accept any good idea that users will want or will facilitate that they could want. They must significantly advance our goal of having an MVP within the year.

We also welcome any other ideas that we could use. Please review the "Desired Features" section of this website for even more ideas and further necessary information.

Internship Participants​

Many of you reading this page are interested in participating in our various internship programs (eg. Google Summer of Code, GitHub Externship, Google Summer of Docs, Outreachy, etc.).

  1. Make sure to read the relevant Introduction and Application Guide/ Contribution Process pages first.
    1. GSoC:
      1. GSoC Introduction.
      2. GSoC Application Guide.
  2. Review the Selection Criteria to ensure you meet all the requirements for a good proposal.
  3. Use the Application Template as a guide to formatting your application. The tips on this page are very important.

Good luck!

Documentation​

We need to reduce the learning curve of contributors and sysadmins alike. Project work needs to be well documented in our code so that tools can eventually automatically add it to our documentation websites.

Testing​

All code submitted must be tested. We are working towards getting to 100% test code coverage on all Talawa repositories. This will mean that you will have to write tests for new code you write or modify.

The test percent code coverage requirement will incrementally rise with each pull request. In some cases you may have to write a few extra tests for code you may not have updated. We hope this will be rare.

Write code that will work in the long term. Eliminate brittle code that will easily break.

Repository Languages and Skills​

Here is a list of basic skills that will be required for each repository.

  1. Talawa: Flutter / Dart, GraphQL
  2. Talawa-API: Typescript, GraphQL, MongoDB
  3. Talawa-Admin Portal: TypeScript

There are others, but these are the primary ones that will guide your contributions.

Impact Definition​

We have categorized the various ideas according to the degree of impact they will have to the project. Use these definitions to understand how each idea will affect our overall project goals.

  1. Low-hanging fruit: These projects require minimal familiarity with the codebase and basic technical knowledge. They are relatively short, with clear goals.
  2. Risky/Exploratory: These projects push the scope boundaries of our development efforts. They might require expertise in an area not covered by our current development team. They might take advantage of a new technology. There is a reasonable chance that the project might be less successful, but the potential rewards make it worth the attempt.
  3. Fun/Peripheral: These projects might not be related to the current core development focus, but create new innovations and new perspective for our project.
  4. Core development: These projects derive from the ongoing work from the core of our development team. The list of features and bugs is never-ending, and help is always welcome.
  5. Infrastructure/Automation: These projects are the code that our organization uses to get our development work done; for example, projects that improve the automation of releases, regression tests and automated builds. This is a category in which a contributor can be really helpful, doing work that the development team has been putting off while they focus on core development.

Difficulty​

Most of our project ideas require knowledge of two or more programming languages. Meaningful PRs that prove your understanding of the repos will always be beneficial. We have created testing issues specifically for this purpose.

  1. Hard: Requires dominion of the language used by the repo most affected by the project. A good working knowledge of the languages used by other affected repositories will be needed.
  2. Medium: A good working knowledge of the languages used by affected repositories will be needed.
  3. Easy: A beginner's level knowledge of the languages is sufficient.

Research​

Talawa is a suite of applications that are aimed at managing the memberships of community based organizations. This concept may be new to you, and we suggest you research Church and/or Temple Management Software as a starting point. Talawa needs to have a broader reach and your additions to our ideas will make the difference. We have included links to YouTube videos on this page that will be useful in improving your understanding.

Your solution should ideally consider the:

  1. ability of typical small community organizations with limited resources to:
    1. get tech support to maintain the application
    2. have tech-savvy users
    3. afford long term costs
    4. need all membership information completely under their control
    5. manage services outside the applications
  2. impact of using third party services
  3. performance / usability trade-offs
  4. potential data residency law requirements

Other​

We will not support administrative functions in the mobile app.

General - Primary Idea Areas​

This section outlines the primary features we'd like to implement in the coming months with impacts on all the applications.

Please read the Research section of this document for background information

General: Basic Functionality​

There are some fundamental features that the Talawa suite of applications needs to have. We provide some insights into possible actions here. Any lists in this section should be viewed as inspiration, much more could be done!

  1. Description: Recent projects have focused on creating major improvements in the backend functionality to the detriment of fixing basic functionality in the user facing repos namely Talawa and Talawa-Admin. Our improved testing code coverage means that we get few fatal crashes, but many expected UX features don't respond as expected. For example:

    1. Links: Clicked links and icons are frequently unresponsive
    2. Event Management:
      1. We used to be able to assign tasks to persons invited to events and those assigned tasks would be visible in the mobile app. This no longer happens.
      2. It would also be good for all persons assigned tasks at an event to see each other's assignments. This needs to be addressed from the mobile app end user's perspective and that of the Admin panel.
      3. Events are currently listed as sortable tiles. A calendar view option could be considered.
    3. Image Management: Image uploads don't function as expected.
    4. Layouts: Not all elements in the mobile app respond to changes between from light to dark modes.
    5. Updates: Many menus don't allow updates or don't allow you to edit all the fields added when the menu item was created.
    6. Newsfeed: The layout of the mobile app newsfeed is not intuitive. Adding items to this newsfeed needs to function like other well known mobile apps with this feature.
    7. Chat:
      1. Creating new chats in the mobile app causes it to crash.
      2. Persons invited to events should be automatically added to the event chat groups, but this does not occur.
      3. Verify and correct if necessary whether removing someone from an event invitee list removes them from the group chat.
    8. Errors: Though we have a standard error widget in the mobile app, it is not used for all error reporting, nor does the widget log to console for troubleshooting.
    9. Testing:
      1. Test code coverage in the mobile app lags that of the other Talawa apps. It should ideally be above 90%
      2. We need an automated end-to-end testing regime for all three Talawa code repositories.
    10. Timeliness: The changes will need to be done on a weekly basis. The rest of the community will need to be made aware of changes so that they can add functionality.

  2. Expected Outcomes:

    1. We have documented many other areas of potential improvements in the reference links below. After reviewing the videos there, we decided to create issues to rectify some of our concerns, but soon realized that this warrants a GSoC idea of its own as some solutions to the issues will require great coordination and time.
    2. In addition to fixing the bugs above, consider any other ways of making the obviously desired functionality of Talawa and Talawa Admin work!
      1. This document highlights many sites and videos to aid your research.
      2. Any new features you plan to add as part of this project must be incremental, so that they can be completed in a week. We are certain that there are many opportunities to include these mini projects.
    3. We have created issues to fix some of these obvious defects.
    4. These fixes will ideally not be limited to current defects, but to also to those that may be introduced throughout the GSoC period. We have a history chronic instability and feature malfunctions across all repositories. This project is aimed at looking for ways to improve this now and in the medium to long term.
    5. Reference links: These videos will be valuable in identifying obvious bugs in the functionality, and should provide you with inspiration for other simple features to be added.

  3. Repos to update: Talawa, Talawa-API, Talawa-Admin

  4. Skills Required: Code stacks related to repos above. See introduction section.

  5. Depends on Project: Admin: UI Redesign. Many of the projects below will have some impact, and you will need to coordinate with the assigned mentees for this.

  6. Project Size: 350

  7. Possible Mentors: Ritik Kumar Srivastava (@cyberwake), Aditya Birangal (@AdityaBirangal)

  8. Difficulty: Medium

  9. Impact Definition: Core development

Mobile App - Primary Idea Areas​

This section outlines the primary features we'd like to implement in the coming months for Talawa mobile app.

Please read the Research section of this document for background information

Mobile App: Creating new features and refactoring existing features into Plugins​

  1. Description: There are a number of features that while useful are not absolutely necessary for the base Talawa app and would be better suited as plugins. The goal of this task is to refactor the existing plugins such as Newsfeed Advertising, Spam Mitigation, Inter-group Messaging, Analytics Integration, Check-ins functionality, etc. We recommended that you use our Plugin Guide. The scope of the Newsfeed Advertising and Spam Mitigation are given below. They can act as a template for the any additional plugins you wish to discuss with the mentors.
    1. Newsfeed Advertising:
      1. Community organizations often rely on the support of local businesses. This plugin would allow companies to advertise on the mobile application newsfeed. The plugin must consider both inexperienced advertisers who will only provide an image or video, and those who are more experienced users of online platforms.
      2. Features
        1. The type of content and ways to upload and display it (product placement) must be considered.
        2. The plugin must provide a comprehensive set of advertising campaign features.
        3. Integration with other advertising platforms should be considered.
    2. Spam Mitigation:
      1. Detect whether a user is spamming organization chat and news feed messages.
      2. Features:
        1. A reliable method to intercept new messages
        2. An accurate subsystem to evaluate the spaminess of messages using both implied and explicit triggers.
        3. Notification of the Talawa-Admin users of potential spam
        4. Creation of ways to ban both infringing and related users.
        5. This should ideally be a plugin so that administrators can eventually select the anti-SPAM engine of their choice.
  2. Expected Outcomes:
    1. Architectural Design
      1. Easy to install, enable and remove either online or by the uploading of code
      2. Able to be installed, activated and configured at the global and/or per-organization level served by the API.
      3. Easy to configure in the Talawa-Admin portal.
    2. Plugin - Donations, Member Fees and Paid Events
      1. Organization admins must be able to install and enable the plugin.
      2. Allow organizations exposure to different types of customizable services and activities, which can be both one time or recurring.
      3. Mobile app users must be able to select their preferred options in an easy and intuitive way.
      4. The mobile app must be plugin aware
  3. Repos to update: Talawa, Talawa-API, Talawa-Admin
  4. Skills Required: Code stacks related to repos above. See introduction section.
  5. Depends on Project: None
  6. Project Size: 350 hours (Large)
  7. Possible Mentors: Tasneem Koushar (GitHub: tasneemkoushar), Dominic Mills (GitHub: DMills27)
  8. Difficulty: Hard
  9. Impact Definition: Core development

Mobile App: Improved Member Management and News Feed​

  1. Description: We need to generally improve the way the apps interact with the general membership through the use of the Talawa-Admin portal. For example:
    1. Community organizations will not want to have open membership. At the moment anyone knowing the Talawa-API URL can join an organization. This could create opportunities for malicious actors.
    2. Community organizations need to be able to send notifications to all, or groups of members. This could be required for natural disasters, fundraisers, functions or other significant events. Similarly, mobile app users should be able to notify administrators of inappropriate behavior with the administrator having the ability to alert and eventually take disabling actions from the Admin panel.
  2. Expected Outcomes:
    1. New Members
      1. There needs to be a way for pre-approved persons to join an organization with their mobile app.
      2. There must be a way to allow only certain organization members to approve new members.
      3. This feature needs to be managed via the Talawa-Admin portal.
      4. Make sure the app does not have any admin features.
    2. Notifications
      1. Implement in-app notification scheme that is suitable for major foreseeable use cases.
    3. Posts Improvement
      1. Improved user interface.
      2. Ability to:
        1. Report posts and people.
        2. Tag people so they can be notified.
        3. Use #hashtags.
      3. User can delete a post.
      4. Feature to repost a post for better reach.
      5. Enable various reactions to a post (currently user can only like the post).
      6. Evaluate whether we need newsfeed posts with titles
      7. Think of new ways of handling the pinned posts feature
  3. Repos to update: Talawa, Talawa-API, Talawa-Admin
  4. Skills Required: Code stacks related to repos above. See introduction section.
  5. Depends on Project: None
  6. Project Size: 350 hours (Large)
  7. Possible Mentors: Md Noman Khan (GitHub: noman2002), Aditya Birangal (@AdityaBirangal)
  8. Difficulty: Medium
  9. Impact Definition: Risky/Exploratory

Mobile App: Share data between Talawa and other application suites​

  1. Description: Currently the Posts are made via Admin Portal and Users can like & comment via mobile app. An Ability to publish the posts by providing a publicly accessible link will enable app users to share the posts across other apps like WhatsApp, Twitter, etc. This will help to increase the popularity of the organization. The published post should also be SEO friendly. We also need other applications to be able to share data to Talawa from where users can share content from applications like WhatsApp, telegram etc. to users on Talawa via chat. We really want that Talawa users should also be able to have a preview of links at least from some predefined types stated in Expected Outcomes. When it comes to user retentions we would really like to have a floating PIP mode for the links that have playable video links similar to what telegram and WhatsApp have for YouTube videos.
  2. Expected Outcomes:
    1. Design public posts API and data models.
      1. Ability to share them to others apps via Mobile app.
      2. Implementing logic for built-in SEO for the post.
    2. Implement data sharing to/from Talawa.
      1. Ability to share post from Talawa to other applications.
      2. Post shared should open directly inside app if installed similar to invite feature implemented.
      3. Ability to share plain text, images or both to Talawa users in chat from other applications similar to telegram, WhatsApp, stack have.
      4. This might also require updating changes in chat schema.
      5. Ability to have a link preview of all the links.(Open for whom you want to implement this)
      6. Have a PIP mode for videos to be played inside Talawa when app is in foreground or background state.
      7. Links which have a playable video file like YouTube etc. should have a PIP compatibility.
      8. Links should open inside in-app browser or the dedicated application if installed.
      9. Link preview should also be available for posts on platform and any potential place.
  3. Repos to update: Talawa, Talawa-Admin, Talawa-API.
  4. Skills Required: Code stacks related to repos above. See introduction section.
  5. Depends on Project: None
  6. Project Size: 350 hours (Large)
  7. Possible Mentors: Ritik Kumar Srivastava (@cyberwake), Tasneem Koushar (@tasneemkoushar)
  8. Difficulty: Medium/Hard
  9. Impact Definition: Core development, Risky/Exploratory

API - Primary Idea Areas​

This section outlines the primary features we'd like to implement in the coming months for Talawa API.

Please read the Research section of this document for background information

API: Multi-Tenancy​

  1. Description: Create a way to separate different API instances using a data segregation strategy to best optimize resources. It is likely that we will want to host Talawa as a service. Designing a solution to this problem is therefore required. Read our core concepts document for further background.
  2. Expected Outcomes:
    1. Research and suggest a preferred way of implementing this strategy.
    2. Implement the strategy so that it is transparent to the mobile app.
    3. Code ways to configure this solution simply via the Admin portal.
  3. Repos to update: Talawa-API, Talawa-Admin
  4. Skills Required: Code stacks related to repos above. See introduction section.
  5. Depends on Project: Admin: Multi-Tenancy
  6. Project Size: 350 hours (Large)
  7. Possible Mentors: Mikey Lue (GitHub: JamaicanFriedChicken), Saiabhiteja Chepuri (GitHub: saiabhiteja)
  8. Difficulty: Hard
  9. Impact Definition: Core development, Risky/Exploratory

API: Improved Backend Performance and Security​

  1. Description: The backend has some known deficiencies that need to be addressed.
    1. The current GraphQL implementation uses many anti GraphQL patterns. The root Query field should be used sparingly. All the data required by the client which is relational should be queryable under a single query field. Relay's node interface pattern needs to be introduced to make querying data objects which implement the node interface at any level therefore reducing the use of root Query field unnecessarily.
    2. The resolvers need to be batched to avoid N+1 query problem in GraphQL.
    3. Computationally expensive relation fields in schema should be smartly resolved only when the clients specifically ask for those fields in their queries. Also, circular references should be avoided wherever possible. The relation flow should always strive to go from the parent objects to child objects and not the other way around.
    4. There needs to be a query cost analysis system which makes sure that clients can't make an enormously big query that could take down the database itself because of computational cost.
    5. There needs to be strict input validation system which enforces certain conditions on the clients regarding the input they're sending through their queries. These checks would make sure that the incoming input from the clients is within the expected range of what the business layer expects.
    6. The API allows anyone to do updates. There is security by obfuscation where capabilities are not presented to the user, but are still available. This allows for malicious actors to adversely affect organizations.
    7. Data is insufficiently encrypted
    8. There needs to be a proper system in place to monitor changes in the GraphQL schema. The schema should not introduce breaking changes without prior notice to the clients. Clients should be aware of all the changes happening in the schema so that they're able to migrate their code to work with the newer schema easily. Most of the time deprecated fields in the schema can be supported for long durations of time because GraphQL gives us this flexibility.
  2. Expected Outcomes:
    1. Dependencies
      1. We need to ensure that all dependencies are up-to-date. Some packages used are deprecated, some are not being actively maintained. If not fixed, this will put all future changes to the repository at risk. Don't just consider upgrades, also think of what packages are best for the long term viability of Talawa-API and why.
      2. Research and implement ways to ensure that pull requests are automatically generated whenever dependencies need to be updated.
    2. GraphQL
      1. Implement ways to resolve relational data wherever possible within a single query reducing the need to introduce fields on root Query type unnecessarily.
      2. Research and implement ways to batch queries for optimization.
      3. Implement ways to prevent resolving certain computationally expensive fields unless the clients explicitly asks for them.
      4. Implement a system for query cost analysis for incoming GraphQL queries.
      5. Evaluate and code ways to selectively cache data for reuse depending on the use case.
      6. Update the client apps to make use of GraphQL's data normalization feature.
    3. Input Validation
      1. Research and implement ways to validate user input.
      2. Implement a functionality to return proper errors to the clients describing exactly the problems their input has. A certain level of immutability should be present so that the clients designing their UI behaviors according to these errors don't have to deal with their UI implementations breaking because of changes in returned errors.
      3. The strategy should take type-safety and code reuse into consideration.
    4. Access Security
      1. Implement roles tied to access and refresh token keys
    5. Encryption
      1. Implement ways to encrypt all information exchanged between the API, the mobile app and the Talawa Admin portal.
      2. Implement ways to encrypt PII data stored on disk.
    6. GraphQL schema monitoring
      1. Implement ways to monitor different level of changes in the GraphQL schema.
      2. Implement ways to inform clients of newly added, deprecated or removed fields from the GraphQL schema.
  3. Repos to update: Talawa, Talawa-API, Talawa-Admin
  4. Skills Required: Code stacks related to repos above. See introduction section.
  5. Depends on Project: "API and Mobile App: E2E encryption and security improvement in Talawa and Talawa-API"
  6. Project Size: 350 hours (Large)
  7. Possible Mentors: Kevonia Tomlinson (GitHub: Kevoniat)
  8. Difficulty: Medium
  9. Impact Definition: Core development, Risky/Exploratory

API: Translations and Microservices​

  1. Description: Our proposed project aims to enhance our existing app by allowing users to add language JSON files of their choice, breaking APIs, pub sub, and consumers as separate services, and handling big async processes using Kafka Consumers. Currently, we have a monolithic service that uses GraphQL APIs and pub sub. This project will help us create a more modular and scalable architecture for our app, making it easier to maintain and add new features.
    1. To implement this project, we will first create a language management system that allows users to upload JSON files with translations for the app's content. These translations will then be integrated into the app, enabling users to access the app's content in their preferred language.
    2. Next, we will create separate services for APIs, sockets, and consumers. Breaking these services apart will enable us to manage them more efficiently, as well as allow us to scale and add new features more easily.
    3. To handle big async processes, we will use Kafka Consumers. Kafka Consumers will allow us to process large amounts of data efficiently and handle high traffic volumes, improving the app's performance and reliability.
  2. Expected Outcomes:
    1. Our proposed project will build on previously stated ideas and include some overlap with their general objectives. We will create new features that users will want, including the ability to add language files, improve app performance, and create a more scalable architecture.
    2. The project will justify 350 hours of work, as it involves significant changes to the app's architecture and the creation of new features.
    3. To implement this project, we will require skills in the code stacks related to Talawa, Talawa-API, and Talawa-Admin. Specifically, we will need expertise in GraphQL, Kafka, Python and Sockets.
  3. Instructions: To implement this project, we recommend the following steps:
    1. Develop a language management system that allows users to upload JSON files with translations for the app's content.
    2. Break the APIs, sockets, and consumers into separate services.
    3. Use Kafka Consumers to handle big async processes.
    4. Test and deploy all the services.
    5. Throughout the implementation process, it will be essential to take care of internal server calls and ensure that the app's performance and reliability are not impacted by the changes. We recommend testing each component thoroughly before deployment.
  4. Repos to update: Talawa, Talawa-API, Talawa-Admin
  5. Skills Required: Code stacks related to repos above. See introduction section.
  6. Depends on Project: None
  7. Project Size: 350 hours (Large)
  8. Possible Mentors: Sumitra Saksham (@sumitra19jha), Saiabhiteja Chepuri (@saiabhiteja)
  9. Difficulty: Hard
  10. Impact Definition: Risky/Exploratory

Semiotics​

  1. Description: There is no guarantee that Talawa users will be functionally literate. We need to find ways to augment text with symbols to improve the UX.
  2. Expected Outcomes: TBD
  3. Repos to update: Talawa, Talawa-API, Talawa-Admin
  4. Skills Required: Code stacks related to repos above. See introduction section.
  5. Depends on Project: N/A
  6. Project Size: 350
  7. Possible Mentors: TBD
  8. Difficulty: Medium
  9. Impact Definition: Risky/Exploratory

E2E Testing​

  1. Description: We need better integration testing of the various applications
  2. Expected Outcomes: Consider ways to implement testing:
    1. Using packages such as puppeteer, jest or their equivalents
    2. That comprehensively tests the integration of all three major Talawa apps.
    3. References:
      1. https://github.com/PalisadoesFoundation/talawa-admin/pull/580
  3. Repos to update: Talawa, Talawa-API, Talawa-Admin
  4. Skills Required: Code stacks related to repos above. See introduction section.
  5. Depends on Project: N/A
  6. Project Size: 350
  7. Possible Mentors: TBD
  8. Difficulty: Medium
  9. Impact Definition: Risky/Exploratory

API and Mobile App: E2E encryption and security improvement in Talawa and Talawa-API.​

  1. Description: Currently passwords from frontend are sent on plain text format to the server which is not good to have since these can we tracked by tracing HTTP calls over the network. We want to improve this and send password in SHA256 format beforehand to discourage such tracing and minimize direct attacks on server. We also want that our servers should only respond to authorized clients hence we figured out to implement SSL pining. In our case we cannot do this by hard-coding the certificated in our client rather we would have to do is dynamically by publicly sending a signed certificate only when the user is authorized added he can only download that once per login. This requires changes to be made on Talawa GraphQL client and in the Talawa-API to be able to send signed certificate. Followed by this we want our users to not think of there privacy just focus on sharing text to their peers by making there chat private to them only.
  2. Expected Outcomes:
    1. Design changes in API.
      1. Making login and signup mutations only public mutation which work without SSL pining.
      2. Make a new mutation/query to allow download of signed certificate on Talawa.
      3. Ability to store/retrieve chats in E2E encrypted form.
    2. Implement E2E in Talawa.
      1. Passwords in login and signup mutations should be sent to server after undergoing a SHA256 encryption only.
      2. Soon after successful authorization signed certificate needs to be downloaded which is needed to be attached with every call except login, signup and reset password.
      3. Ability to make E2E for one to one chat in the initial phase. Followed by group chats.
    3. Implement E2E in Talawa-Admin
      1. Send password in SHA256 format rather than sending them in plain text format. Also, SSL pining in admin portal can be done in the conventional way by added a pre-signed certificate before deploying. Making things easier on admin side.
  3. Repos to update: Talawa, Talawa-API, Talawa-Admin.
  4. Skills Required: Code stacks related to repos above. See introduction section.
  5. Depends on Project: "API: Improved Backend Performance and Security"
  6. Project Size: 350 hours (Large)
  7. Possible Mentors: Md Noman Khan (GitHub: noman2002), Nishnata Debnath (GitHub: nishnatadebnath)
  8. Difficulty: Medium/Hard
  9. Impact Definition: Core development, Risky/Exploratory

Admin - Primary Idea Areas​

This section outlines the primary features we'd like to implement in the coming months for Talawa Admin.

Please read the Research section of this document for background information

Admin: UI Redesign​

We always need intuitive layouts and workflows. This applies to both existing features that could be improved or made functional in this area and brand-new ones you consider. Any lists in this section should be viewed as inspiration, much more could be done!

  1. Description: The current Talawa-Admin design is insufficiently intuitive. There are also many buttons that are unused without any indication that they are disabled. We need a UI that considers the users' perspective. This should be done with the following general considerations
    1. Deployment: We want to avoid the size of any required initial monolithic change. Changes must be incremental, possibly one screen at a time. All tests must pass with each change.
    2. Layouts: Layouts will need to be created for use by other members to implement features. This may be facilitated by creating standardized, modular templates for commonly expected functions that could be added to the repository.
    3. Devices: The new design must be reactive, automatically adjusting the layout for all sizes of screens including but not limited to desktop, laptop, tablet and phone devices.
    4. Timeliness: The changes will need to be done on a weekly basis. The rest of the community will need to be made aware of changes so that they can add functionality.
    5. Placeholders: We want placeholder links for all planned features as a reminder that they need to be implemented. These unused placeholders should be greyed out.
    6. Coding: We expect the layouts to be coded in Typescript by the person assigned this idea
  2. Expected Outcomes: This is a sub-set of the features we feel could be added:
    1. A NavBar focusing on overall dashboard, Talawa newsfeed, people in the organization, tags for grouping people, organization events and plugins
    2. Improved intuitive layouts and workflows for:
      1. Managing multiple organizations
      2. Doing CRUD activities
      3. Filtering people and tags
      4. Viewing organization events
      5. Requesting volunteers at events
      6. Doing event checkins
      7. Managing pinned posts on the newsfeed
    3. A properly documented design system and style guide added to the Talawa-Docs repository
    4. Any existing non-functioning features in these areas will need to be resolved.
    5. There are other ideas that will depend on this work. You must think of ways where all participants can add pages according to your design specification without interrupting the speed of development. Strategies for incremental versus monolithic change must be considered.
    6. Any others you can think of!
    7. Reference links: We realize that you may be new to the world of community management. These links should be used as a non-exhaustive guide.
  3. Repos to update: Talawa-API, Talawa-Admin
  4. Skills Required: Code stacks related to repos above. See introduction section.
  5. Depends on Project: General: Basic Functionality
  6. Project Size: 350
  7. Possible Mentors: Anwer Sayeed (GitHub: @anwersayeed), Muskan Modi (GitHub: @muskan399)
  8. Difficulty: Medium
  9. Impact Definition: Core development

Admin: Improved Event Management​

We always need intuitive layouts and workflows. This applies to both existing features that could be improved or made functional in this area and brand-new ones you consider. Any lists in this section should be viewed as inspiration, much more could be done!

  1. Description: There are many ways in which event management could be improved for the benefit of administrators who are constantly having to manage their volunteers and track the successes of the events they manage.
    1. Volunteer Management: The mobile app allows people to create calendars and add volunteers for specific roles. This is good for creating ad hoc events by organization members. There needs to be a way for the organization's administrators to manage event volunteers:
    2. Checkins: We need a way for Admin users to track who attended what event and when. Administrators cannot depend on people using their phones to do this, so it will need to be done by volunteers using Talawa-Admin. This is important for many reasons:
      1. Security: Some organizations have events that provide child care.
      2. Management: The ability to track attendance trends and investigate ways to improve it.
  2. Expected Outcomes: This is a sub-set of the features we feel could be added:
    1. Event Calendar:
      1. The organization's event calendar needs to more closely resemble a calendar.
    2. Volunteer Management:
      1. Easily add custom role tags to members of the organization
      2. Create groups and subgroups of member tags for ease of categorization. (eg. Cooks, Barbecue cooks)
      3. Manually add members to an organization and match them to existing mobile users if they exist. (Not all members will use phones)
      4. See all scheduled events in an organization wide calendar.
      5. Assign volunteers to any event.
      6. Assign leaders to any event.
      7. Mobile app notification when someone has been added as "Volunteer".
      8. Upcoming events for volunteers in mobile app.
      9. Any others you can think of!
      10. Reference links: We realize that you may be new to the world of community management. These links should be used as a non-exhaustive guide.
    3. Checkins
      1. Attendance registration for caregivers and those they care for
      2. The ability to print sticky labels for attendees
      3. Safeguards to make sure parents of children are easily matched
      4. An event dashboard listing attendees and contact details
      5. Attendance reporting over date ranges
      6. Notifications when people stop attending
      7. The ability to limit volunteers using Admin to only the checkin screens
      8. Usability on a variety of screen sizes
      9. Ability to send notification directly on mobile app (example: any urgent information to be circulated while ongoing event).
      10. Dashboards showing attendance stats for single and recurring events
      11. Any others you can think of!
      12. Reference links: We realize that you may be new to the world of community management. These links should be used as a non-exhaustive guide.
  3. Repos to update: Talawa-API, Talawa-Admin
  4. Skills Required: Code stacks related to repos above. See introduction section.
  5. Depends on Project: Admin: UI Redesign
  6. Project Size: 350
  7. Possible Mentors: Ritik Kumar Srivastava (@cyberwake), Dominic Mills (GitHub: DMills27)
  8. Difficulty: Medium
  9. Impact Definition: Risky/Exploratory

Admin: Improved People and Newsfeed Management​

We always need intuitive layouts and workflows. This applies to both existing features that could be improved or made functional in this area and brand-new ones you consider. Any lists in this section should be viewed as inspiration, much more could be done!

  1. Description: The Talawa admin panel does not intuitively manage people assigned to an organization. We need:
  2. Expected Outcomes: This is a sub-set of the features we feel could be added.
    1. People and Tags: The ability to easily:
      1. see listings of users
      2. search and filter for users by assigned tag or profile characteristic
      3. implement CRUD management for all
    2. Newsfeed: The ability to easily:
      1. view and post to the Talawa newsfeed
      2. respond to reported newsfeed posts and take appropriate action
      3. pin posts to the top of the newsfeed
    3. Any others you can think of!
    4. Reference links: We realize that you may be new to the world of community management. These links should be used as a non-exhaustive guide.
  3. Repos to update: Talawa-API, Talawa-Admin, Talawa
  4. Skills Required: Code stacks related to repos above. See introduction section.
  5. Depends on Project: Admin: UI Redesign
  6. Project Size: 350 hours (Large)
  7. Possible Mentors: Tyrone Taylor (GitHub: ttaylor92), Anthony Brown (GitHub: tonythegr8)
  8. Difficulty: Medium
  9. Impact Definition: Risky/Exploratory

Admin: Multi-Tenancy (Cloud)​

  1. Description: Create a way to easily manage multiple instances of Talawa-API from a single Talawa-Admin panel. This would provide control over multiple communities (parent organizations) and their respective (child) organizations. Read our core concepts document for further background.
  2. Expected Outcomes:
    1. Research and suggest a preferred way of implementing this strategy.
    2. Implement the strategy so that it is transparent to the mobile app.
    3. Code ways to configure this solution simply via the Admin portal.
    4. Think of:
      1. New levels of authorization and security that may be required.
      2. Architectures that would facilitate moving a community from one server to another on a completely different set of infrastructure.
      3. Interesting features that would be required for this to be implemented.
  3. Repos to update: Talawa-API, Talawa-Admin
  4. Skills Required: Code stacks related to repos above. See introduction section.
  5. Depends on Project: API: Multi-Tenancy
  6. Project Size: 350 hours (Large)
  7. Possible Mentors: Sumitra Saksham (@sumitra19jha), Eva Sharma (@evasharma12)
  8. Difficulty: Hard
  9. Impact Definition: Core development, Risky/Exploratory

Hybrid - Primary Ideas​

We realize that this list isn't exhaustive. There are many more opportunities that could be converted into project ideas and proposals. If this is what inspires you, then investigate this section

Hybrid: Hybrid Innovation​

  1. Description: Do the ideas need something more? What completely new thoughts could be applied to the existing ideas? If you have answers to these questions then this section is for you.
  2. Expected Outcomes: Your proposal must meet the guidelines below. They must:
    1. Not depend on other participants. There should be minimal impact by other participants disappearing or doing a very bad or very good job.
    2. Add completely new features not previously stated in ideas.
    3. Create features that users will want or facilitate new features that will be the groundwork for features that they would want.
    4. Justify 350 hours of work.
  3. Repos to update: Talawa, Talawa-API, Talawa-Admin
  4. Skills Required: Code stacks related to repos above. See introduction section.
  5. Depends on Project: N/A
  6. Project Size: 350
  7. Possible Mentors: Sagar Utekar (@Sagar2366), Eva Sharma (@evasharma12)
  8. Difficulty: Medium
  9. Impact Definition: Risky/Exploratory