Forem: sateshcharan

🔐 Benefits and Drawbacks of Passkey-Only Login Systems

sateshcharan — Sun, 27 Oct 2024 10:32:42 +0000

Guest Author: sateshcharan

If you've recently noticed a "Sign in with a passkey" option on sites like GitHub, Vercel or Google, you're not alone – passkeys are gaining traction quickly. Here's a quick rundown of the pros and cons of switching to a passkey-only system. 🔐

🔹 Quick Overview of Passkeys
Passkeys, aka WebAuthn credentials, are secure, public-key-based authentication credentials designed to replace passwords and make logging in both easier and safer. They let you log in to apps and websites without needing a password by using biometrics like Face ID, Touch ID, or a device PIN. 💻

✅ Benefits of Passkey-Only Systems

1. Superior Security

🛡️ Since passkeys are tied to specific websites, they’re a inherently defensive against phishing.
🔒 No more weak or reused passwords, and database breaches have less impact.

2. Smooth User Experience

🧠 Users don’t need to create, remember, or manage passwords.
⚡ Log in with a quick biometric scan or PIN.

3. Low Support Costs

💸 Fewer Password Resets: No more forgotten passwords to reset!
🔄 Simplified Account Recovery: Account recovery can be managed through the user’s device or platform account.

4. Cross-Platform friendly

📲 Passkeys can sync across devices seamlessly on many platforms.
🌐 Works on different operating systems and browsers supporting WebAuthn.

❌ Drawbacks of Passkey-Only Login Systems

1. Low User Adoption Trend

📚 Many users are still new to passkeys, so some guidance may be needed.
🌍 Not all browsers or platforms support passkeys yet.

2. Device Dependent

📱 If a user loses access to their device, **recovery **might be tricky.
🚚 Moving passkeys to a new device can be a bit of a hassle.

3. Complex to Implement

🛠️ Developers need to make substantial changes to backend authentication.
🌐 Different device capabilities mean extra work to ensure fallback options.

4. Lock-In Risk

🔒 Some users might feel locked into specific **ecosystem **providers like Apple or Google.
🔍 Passkey management by these platforms can raise privacyconcerns.

🎉 Wrapping Up

Passkey-only login systems offer a lot of advantages in terms of security, ease of use, and support savings. However, challenges with adoption, implementation, and platform dependency remain. As the tech evolves, many of these challenges may get easier. For developers interested in implementing passkeys, it's best to offer clear user instructions, create strong fallback options, and consider a phased approach that combines passkeys with traditional logins. 🚀

🔒 Complete Authentication and User Management solution
If you’re looking for a complete management solution, Hanko should be your go to choice. You can integrate from passwords all the way to passkeys, 2FA, and SSO. (MFA coming in Oct).

The best part is it’s Open-source. You can checkout their Github. Star the repo to show your support!

🚀 Supercharge Your Marketing with TwentyCRM + n8n

sateshcharan — Fri, 25 Oct 2024 18:42:12 +0000

If you're managing customer relationships, you need to check out TwentyCRM! I recently discovered it through oss.gg, and after years of using clunky traditional CRMs with limited flexibility, TwentyCRM has been a game-changer. It’s packed with modern integrations right out of the box, offering flexibility that feels like a night-and-day difference.

But here’s where it gets really exciting—what if you could automate your marketing tasks, email campaigns, or even perform sentiment analysis using tools like n8n? With TwentyCRM and n8n, you can! Let’s dive in to see how it’s done. 🧠✨

TL;DR:

From "Self hosting with modified docker files" section:

Set up .env file with necessary environment variables.
Use the code for docker-compose.yml and run:

docker compose up -d

Login to your applications:
- Generate API keys for CRUD operations in TwentyCRM, save the credentials in n8n, and use them with the HTTP Request module in n8n.
- Set up a Webhook trigger in n8n for event-driven communication if needed, and save the generated URL in TwentyCRM.
Build, test, and deploy your workflow to automate your processes seamlessly.

🧩 Why Integrate TwentyCRM with n8n?

TwentyCRM provides a solid, modern CRM foundation, and when integrated with automation tools like n8n, it eliminates repetitive tasks, boosts productivity, and expands functionality by integrating with hundreds of modules.

Visit TwentyCRM to know more

Visit n8n to know more

🖥️ System Requirements

Managed Environment with Official Support

No requirements; all resources are handled by the service provider

Self Hosting

RAM: A minimum of 2GB is recommended to prevent crashes due to insufficient memory.-
Docker & Docker Compose: Ensure both are installed and up-to-date.

⚙️ Setting Up the Environment
There are two options for setting up TwentyCRM and n8n:

☁️Managed Environment with Official Support
TwentyCRM and n8n offer managed services that are super easy to set up and affordable. If you're looking for a hassle-free start, this option would suit you best

Visit the websites of TwentyCRM and n8n.
Click “Sign Up” and register.
Upon successful registration you'll be able to login.

🏠Self-Hosting Setup
If you prefer self-hosting, TwentyCRM and n8n have open-source versions that you can install with limited features:

🖥️💾Self Hosting with Official docker-compose files

TwentyCRM offers a convenient One-line script:
From your terminal, run:

Download the docker-compose.yml file:

bash <(curl -sL https://git.new/20)

Launch TwentyCRM Containers

cd twentycrm
docker-compose up -d

You can then access TwentyCRM by opening: http://localhost:3000

Create volume for n8n persistence

docker volume create n8n_data

Start n8n docker container

docker run -it --rm --name n8n -p 5678:5678 -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n

This command will download all required n8n images and start your container, exposed on port 5678. To save your work between container restarts, it also mounts a docker volume, n8n_data, to persist your data locally.

You can then access n8n by opening: http://localhost:5678

🖥️🤖Self Hosting with modified docker-compose files(⚠️ Advisable only for advanced users)
Alternatively, you can leverage AI to generate a combined docker-compose.yml file by merging individual files into a single container setup. This approach simplifies troubleshooting and streamlines networking between containers, making your workflow much easier to manage.

version: "3.9"
name: twenty

services:
  change-vol-ownership:
    image: ubuntu
    user: root
    volumes:
      - server-local-data:/tmp/server-local-data
      - docker-data:/tmp/docker-data
    command: >
      bash -c "
      chown -R 1000:1000 /tmp/server-local-data
      && chown -R 1000:1000 /tmp/docker-data"

  server:
    image: twentycrm/twenty:${TAG}
    volumes:
      - server-local-data:/app/packages/twenty-server/${STORAGE_LOCAL_PATH:-.local-storage}
      - docker-data:/app/docker-data
    ports:
      - "3000:3000"
    mem_limit: 2g  # Memory limit for standalone Docker Compose setup

    environment:
      PORT: 3000
      PG_DATABASE_URL: postgres://twenty:twenty@${PG_DATABASE_HOST}/default
      SERVER_URL: ${SERVER_URL}
      FRONT_BASE_URL: ${FRONT_BASE_URL:-$SERVER_URL}
      REDIS_PORT: ${REDIS_PORT:-6379}
      REDIS_HOST: ${REDIS_HOST:-redis}

      ENABLE_DB_MIGRATIONS: "true"

      SIGN_IN_PREFILLED: ${SIGN_IN_PREFILLED}
      STORAGE_TYPE: ${STORAGE_TYPE}
      STORAGE_S3_REGION: ${STORAGE_S3_REGION}
      STORAGE_S3_NAME: ${STORAGE_S3_NAME}
      STORAGE_S3_ENDPOINT: ${STORAGE_S3_ENDPOINT}

      ACCESS_TOKEN_SECRET: ${ACCESS_TOKEN_SECRET}
      LOGIN_TOKEN_SECRET: ${LOGIN_TOKEN_SECRET}
      REFRESH_TOKEN_SECRET: ${REFRESH_TOKEN_SECRET}
      FILE_TOKEN_SECRET: ${FILE_TOKEN_SECRET}
    depends_on:
      change-vol-ownership:
        condition: service_completed_successfully
      db:
        condition: service_healthy
    healthcheck:
      test: curl --fail http://localhost:3000/healthz
      interval: 5s
      timeout: 5s
      retries: 10
    restart: always   

  worker:
    image: twentycrm/twenty:${TAG}
    command: ["yarn", "worker:prod"]
    environment:
      PG_DATABASE_URL: postgres://twenty:twenty@${PG_DATABASE_HOST}/default
      SERVER_URL: ${SERVER_URL}
      FRONT_BASE_URL: ${FRONT_BASE_URL:-$SERVER_URL}
      REDIS_PORT: ${REDIS_PORT:-6379}
      REDIS_HOST: ${REDIS_HOST:-redis}

      ENABLE_DB_MIGRATIONS: "false" # it already runs on the server

      STORAGE_TYPE: ${STORAGE_TYPE}
      STORAGE_S3_REGION: ${STORAGE_S3_REGION}
      STORAGE_S3_NAME: ${STORAGE_S3_NAME}
      STORAGE_S3_ENDPOINT: ${STORAGE_S3_ENDPOINT}

      ACCESS_TOKEN_SECRET: ${ACCESS_TOKEN_SECRET}
      LOGIN_TOKEN_SECRET: ${LOGIN_TOKEN_SECRET}
      REFRESH_TOKEN_SECRET: ${REFRESH_TOKEN_SECRET}
      FILE_TOKEN_SECRET: ${FILE_TOKEN_SECRET}
    depends_on:
      db:
        condition: service_healthy
      server:
        condition: service_healthy
    restart: always

  db:
    image: twentycrm/twenty-postgres:${TAG}
    volumes:
      - db-data:/bitnami/postgresql
    environment:
      POSTGRES_PASSWORD: ${POSTGRES_ADMIN_PASSWORD}
    healthcheck:
      test: pg_isready -U twenty -d default
      interval: 5s
      timeout: 5s
      retries: 10
    restart: always

  redis:
    image: redis
    ports:
      - "6379:6379"
    restart: always

  n8n:
    image: docker.n8n.io/n8nio/n8n
    container_name: n8n.twenty
    ports:
      - "5678:5678"
    volumes:
      - ./n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n
    restart: unless-stopped

volumes:
  docker-data:
  db-data:
  server-local-data:

⚠️before starting ensure that you have setup the environment variables correctly using TwentyCRM docs
Start the containers with docker compose up -d

Now you should have working applications of TwentyCRM & n8n to which you must be able to login to.

⚡ Interacting with TwentyCRM
TwentyCRM provides APIs for CRUD operations in both REST and GraphQL formats, along with webhook support for event-driven integration.

When an event occurs, TwentyCRM will make a POST request to the configured webhook URL based on the permissions set.
The API endpoints are organized into Metadata and Core categories, allowing flexible access based on your needs.
API Access Based on Subscription Plans
Some API endpoints are only accessible with a subscription plans. Here’s a breakdown of the accessible APIs for Free and Paid plans:

API Type	Description	Free Plan Access	Paid Plan Access
Core API	Access to customer data, records, etc.	Restricted	Full
Metadata API	Access to account settings and configurations	Full	Full
Webhook Support	Event-based triggers to external services	Limited	Full
GraphQL API	Flexible data queries	Restricted	Full

The Webhook Support offer limited access on the Free plan, while the Paid plan provides full access, ideal for more complex workflows and automation tasks involving mutations.

Detailed docs can be found at TwentyCRM

TwentyCRM also provides a playground like setup to test endpoint communication:

🛠️ Setting Up the Integration
Seamless integration primarily revolves around three key concepts. Let’s quickly explore these concepts and illustrate them with a simple workflow example.

1. Create Your TwentyCRM API Access

You’ll need an API key to enable communication between TwentyCRM and your automation tool.
Login to TwentyCRM and navigate to Account Settings > Developers > API & Webhooks.
Generate a New API Key with permissions to read customer data and update records as required.
Use the generated key in n8n's HTTP Request module header as follows:

Authorization: Bearer {API_KEY}

2. Setup n8n Webhook endpoint

Create a new workflow in n8n and add a trigger, such as a Webhook, that listens for new customer events in TwentyCRM.
Set the webhook method to POST and copy the generated URL.
Paste the URL into the designated field for the webhook URL in TwentyCRM.
Remember to replace this URL with the production webhook URL once development is complete.

3. Access TwentyCRM data in n8n

Set up the HTTP Request node in n8n.
In this node, use the {API_KEY} generated in Step 1 to fetch customer details from TwentyCRM. [Image idea: Screenshot of n8n workflow canvas with a Webhook and HTTP Request node visible, illustrating the flow setup.]

🧠🤖 AI-Powered API Request Generation (for low and no-code devs)
You might be thinking, "But I don’t know how to write API requests." Don’t worry! Here’s where AI comes in.

GPT-based natural language processing tools can help you write API requests, even if you’re not a coder. You simply describe what your needs as prompts and AI generates the API request for you.

Here’s how we can leverage it:

- Step 1: Describe Your Request
Ask the AI with a prompt like, "Generate a cURL API request to fetch {example} data from TwentyCRM in n8n."

- Step 2: Use the Response
Copy and paste the response into n8n’s HTTP Request node using the Import cURL feature. Adjust any credentials or parameters as needed, and n8n will automatically set up the request for you.

This approach streamlines API setup, making it easier to integrate various services into your workflows.
⚠️Do remember that AI may not always yield the desired result so use with caution.

🧑‍🏫 Using n8n to automate workflow with TwentyCRM

Workflow Overview
This workflow is triggered when a new order is created in Shopify. Then:

The order information is stored in TwentyCRM,
An invoice is created in Harvest and stored in Trello,
If the order value is above 50, an email with a discount coupon is sent to the customer and they are added to a MailChimp campaign for high-value customers; otherwise, only a "thank you" email is sent to the customer.
Step 1: Shopify Trigger
Trigger: This workflow starts when a new order is created in Shopify.
Details: The “Shopify Trigger” node listens for the orders/create event from Shopify, capturing essential details like customer information, order number, and order total.
Step 2: Extract Key Information (Set Fields)
Purpose: This step formats the Shopify order details to make them easily accessible for downstream nodes.
Details: The “Set Fields” node extracts relevant data, including:
Customer’s first name, last name, email, and phone number.
Order total, which is crucial for later decision-making steps.
Step 3: Store Customer Data in TwentyCRM
Purpose: To create or update the customer’s information in TwentyCRM for centralized customer management.
Details: The “TwentyCRM - Upsert Customer” node sends an HTTP request to TwentyCRM’s API to save the customer’s first name, last name, email, and phone number.(AI models can be used to write the required API requests)
Step 4: Generate an Invoice in Harvest
Purpose: To automatically generate an invoice for the order in Harvest.
Details: The “Harvest” node uses the customer’s information and order details to create an invoice with the specified currency and the order number as the purchase order reference.
Step 5: Log Order in Trello
Purpose: To create a Trello card for tracking the order fulfillment process.
Details: The “Trello” node generates a card with the order number and basic order information on a designated Trello list, allowing the team to manage tasks related to this order.
Step 6: Evaluate Order Value (IF - Order Value)
Purpose: To determine if the order qualifies as a high-value purchase.
Condition: The “IF - Order Value” node checks whether the order total exceeds 50. This decision directs the workflow to either send a coupon email or a basic “thank you” email.
Step 7A: Send High-Value Customer Coupon Email (If Order > 50)
Purpose: To encourage repeat purchases for high-value customers.
Details: If the order total is greater than 50, the “Gmail - Send Coupon Email” node sends an email containing a 15% discount coupon for the next purchase.
Step 7B: Add Customer to Mailchimp High-Value Campaign
Purpose: To target high-value customers for future marketing campaigns.
Details: After sending the coupon email, the “Mailchimp” node adds the customer to a Mailchimp list with a “high-order” tag, enabling personalized marketing campaigns.
Step 8: Send Thank You Email (If Order ≤ 50)
Purpose: To acknowledge smaller orders with a personalized thank-you message.
Details: If the order total is 50 or less, the “Gmail - Send Thank You Email” node sends a simple thank-you email to the customer.

🤝Show your support for these amazing projects
🌐TwentyCRM | ✨Star TwentyCRM on github | 📦TwentyCRM docs
🌐n8n | ✨Star n8n on github | 📦n8n docs

🎯 Exited to try? have a go at these workflows:

Creating automatic reminders when leads go cold 🔔
Scoring customer sentiment using AI analysis 🔍

Do you have any cool integration ideas or questions? Drop them in the comments! 👇 Let's brainstorm together!

Unlocking Fundamental Analysis with OpenBB: A Comprehensive Guide

sateshcharan — Mon, 21 Oct 2024 18:40:38 +0000

In the world of investing, understanding the intrinsic value of stocks is crucial for making informed decisions. Fundamental analysis (FA) focuses on evaluating a company's financial health, performance metrics, and overall market conditions to determine its true value. OpenBB, an open-source investment research platform, empowers investors to perform in-depth fundamental analysis with advanced tools and real-time data. This blog post will guide you through using OpenBB for FA in stock markets.

What is Fundamental Analysis?
Fundamental analysis involves examining various financial metrics and qualitative factors to evaluate a company's stock.

Key components include:

Financial Statements: Understanding the balance sheet, income statement, and cash flow statement.
Valuation Ratios: Using metrics like Price-to-Earnings (P/E), Price-to-Book (P/B), and Dividend Yield.
Market Conditions: Considering economic indicators, industry trends, and competitive positioning.

Why Choose OpenBB for Fundamental Analysis?
OpenBB offers a suite of powerful features that make it an ideal tool for
fundamental analysis:

Comprehensive Data Access: OpenBB aggregates vast amounts of financial data from diverse sources, enabling users to analyze multiple asset classes seamlessly.
User-Friendly Interface: The platform is designed for both seasoned investors and beginners, offering intuitive tools to navigate complex data.
Customization: Being open-source, OpenBB allows users to tailor their analysis tools and scripts according to their unique needs.

Getting Started with OpenBB

Step 1: Installation
To begin, you need to install OpenBB. The process is straightforward:

# Clone the repository
git clone https://github.com/OpenBB-finance/OpenBBTerminal.git

# Change directory to the cloned repository
cd OpenBBTerminal

# Install dependencies
pip install -r requirements.txt

# Launch OpenBB
python main.py

Step 2: Accessing Financial Data
Once OpenBB is running, you can access financial data for various stocks. Here’s how to pull fundamental data for a specific stock, such as Apple (AAPL):

> stock.load("AAPL")

This command loads Apple’s financial data, including key metrics from its latest quarterly and annual reports.

Step 3: Analyzing Financial Statements
OpenBB provides detailed views of financial statements. To analyze Apple's income statement, use:

> financials.income_statement()

You’ll see key figures like revenue, net income, and earnings per share (EPS), which are crucial for assessing the company’s profitability.

Step 4: Evaluating Valuation Ratios
Valuation ratios help investors determine if a stock is undervalued or
overvalued. To compute the P/E ratio, simply run:

> valuation.pe_ratio()

You can also check other ratios such as P/B and Dividend Yield:

> valuation.pb_ratio()
> valuation.dividend_yield()

Step 5: Comparative Analysis
OpenBB allows users to compare different stocks easily. For example, if you want to compare AAPL with Microsoft (MSFT):

> stock.compare("AAPL", "MSFT")

This command displays a side-by-side comparison of key financial metrics, helping you make informed investment decisions.

Step 6: Utilizing Advanced Features

OpenBB includes various advanced features for in-depth analysis:

AI-Driven Insights: Utilize machine learning models to predict trends based on historical data.

![Uploading

Custom Scripts: Write Python scripts to automate repetitive analysis tasks.
Visualizations: Use built-in charts and graphs to visualize data for better understanding.

Real-World Use Case
Let’s consider a practical example of using OpenBB for fundamental analysis of AAPL:

Financial Health: You find that Apple has consistently increased its revenue year-over-year, indicating strong growth potential.
Valuation Ratios: After calculating the P/E ratio, you see it is lower than the industry average, suggesting the stock might be undervalued.
Comparative Analysis: Comparing AAPL to MSFT shows that while both are strong performers, AAPL has a higher profit margin, making it a more attractive investment.
Conclusion

OpenBB is a powerful tool for anyone looking to conduct fundamental analysis in the stock market. Its robust data access, user-friendly interface, and customization options make it an invaluable resource for both novice and experienced investors. By leveraging OpenBB's capabilities, you can gain deeper insights into your investments, empowering you to make informed decisions and potentially enhance your financial success.

Ready to elevate your fundamental analysis? Download OpenBB today and explore the wealth of information it offers! For more insights and tutorials, check out the OpenBB documentation.

OpenBB vs. Proprietary Financial Tools: Why Open Source is the Future of Investment Research

sateshcharan — Mon, 21 Oct 2024 17:22:20 +0000

In the world of finance, information is everything. Having access to real-time data, advanced analytics, and comprehensive tools can make or break investment decisions. Traditionally, platforms like Bloomberg and Reuters have dominated the market by providing high-end tools, but they come with significant costs, often out of reach for the average investor. Enter OpenBB, an open-source alternative that’s challenging the status quo by providing robust financial research tools for free.

In this article, we’ll compare OpenBB with proprietary financial tools, focusing on its key features and emphasizing the benefits of an open-source approach to investment research.

The Rise of OpenBB
OpenBB is an open-source investment research platform designed to give everyone—from individual investors to seasoned analysts—access to powerful financial tools. It leverages real-time data, advanced visualizations, and AI-driven analytics to make sophisticated financial research accessible. Whether you're analyzing stocks, cryptocurrencies, commodities, or ETFs, OpenBB offers a broad range of tools at no cost.

Proprietary Tools: The Financial Giants
For decades, proprietary platforms like Bloomberg Terminal and Reuters Eikon have dominated the industry. These platforms provide an unparalleled level of data, real-time analytics, and integration with global financial markets. However, the downside is their high price—Bloomberg Terminal, for example, costs upwards of $24,000 per year. These tools are out of reach for many independent investors, smaller firms, and enthusiasts.

OpenBB vs. Proprietary Tools: Key Comparisons

Let’s break down some key areas where OpenBB competes against proprietary platforms:

1. Cost

Proprietary Tools: As mentioned, tools like Bloomberg and Reuters Eikon come with a hefty price tag, making them accessible mostly to institutional investors or large firms. The subscription fees often run into the thousands of dollars annually.
OpenBB: This is where OpenBB shines the most—it's completely free. Built by a community of developers and financial experts, OpenBB provides high-quality tools without the barrier of cost. This democratizes access to data and analytics, leveling the playing field for all types of investors.

2. Data Access

Proprietary Tools: Bloomberg and Reuters provide an extensive and reliable network of financial data, ranging from stock markets to commodities and even niche sectors. They aggregate data from global markets in real-time and offer deep historical data.
OpenBB: OpenBB sources its data from multiple open and free APIs, covering a wide range of financial assets including stocks, crypto, commodities, and more. While it may not have the extensive market coverage of Bloomberg, OpenBB’s data access is sufficient for most retail investors and smaller financial firms.

3. Advanced Analytics

Proprietary Tools: Bloomberg and Reuters offer sophisticated analytics, including real-time charting, economic indicators, news sentiment analysis, and machine learning integrations. These platforms are designed to handle large-scale institutional analytics.
OpenBB: OpenBB also provides AI and machine learning-powered analytics, allowing users to track market trends, predict asset movements, and optimize their portfolios. While it may not be as expansive as Bloomberg, OpenBB's analytics capabilities are more than sufficient for most users, and they’re constantly improving thanks to the open-source community.

4. Customization and Flexibility

Proprietary Tools: Proprietary platforms come with strict frameworks that limit user flexibility. While they provide rich features, customization often comes at an additional cost, and users are constrained by what the software can offer.
OpenBB: As an open-source platform, OpenBB allows users to fully customize the experience. Developers can tweak the code, integrate their own tools, or modify features to fit specific needs. This level of flexibility is a key benefit for developers and analysts who want a tailored experience. The power of open source means that users aren’t dependent on a single company for updates or improvements—anyone can contribute.

5. Transparency and Security

Proprietary Tools: With proprietary platforms, users don’t have access to the underlying code. They must trust the vendor to ensure that their data is secure and the platform operates correctly. Bugs and security flaws are typically fixed in private by the company, which may take time to address.
OpenBB: OpenBB’s open-source nature ensures complete transparency. Anyone can audit the code to verify its security and reliability. The open-source model encourages quicker identification of bugs, security flaws, and feature gaps, as the global developer community can actively contribute to the platform's improvement.

6. Community and Support

Proprietary Tools: Platforms like Bloomberg and Reuters come with dedicated customer support teams, which is useful for handling issues or learning how to maximize the platform’s features. However, these services often come at an additional cost.
OpenBB: While OpenBB may not offer 24/7 support teams, it benefits from an active and passionate community. The open-source community frequently contributes new features, fixes bugs, and shares tutorials. OpenBB users can access free documentation, community forums, and even contribute directly to the platform’s development.

Concrete Use Case: Individual Investor

Imagine a retail investor who wants to manage their personal portfolio and explore opportunities in both stocks and cryptocurrencies. With a limited budget, they can’t afford Bloomberg or Reuters, but they still need access to high-quality data and advanced analytics. Here’s where OpenBB offers a perfect solution:

Data Aggregation: The investor can track stocks, crypto, and commodities all in one place using OpenBB's powerful data collection features.
AI-Powered Insights: With machine learning, they can predict market movements and optimize their portfolio based on historical data.
**Custom Tools: **If they need a specific feature, they can code it themselves or request it from the OpenBB community.
The Benefits of Open-Source in Finance

The rise of OpenBB highlights a broader trend: open-source tools are becoming increasingly viable in professional spaces that were once dominated by proprietary giants. OpenBB’s open-source approach offers several benefits:

Cost-Efficiency: Free access to powerful tools makes high-quality financial research more accessible to everyone.

Innovation: An open-source platform benefits from continuous updates and innovations contributed by a global community.

Flexibility: Full control over the software means users can customize it to meet their specific needs.

Conclusion

While proprietary tools like Bloomberg and Reuters offer a wealth of features, they come with high costs and limited flexibility. OpenBB, on the other hand, provides a robust, open-source alternative that empowers individual investors, small firms, and even professionals to access advanced financial tools without breaking the bank.

As the open-source movement continues to grow, platforms like OpenBB are setting a new standard for financial research—one that prioritizes accessibility, transparency, and innovation. If you're looking to elevate your investment research without the heavy price tag, OpenBB is a solution worth exploring.

Ready to take control of your financial future with open-source tools? Explore OpenBB today!

#OpenSource #Finance #InvestmentResearch #OpenBB #DataAnalytics

Streamlined Self-Hosting with Twenty CRM: 1-Click Docker Compose Setup

sateshcharan — Mon, 21 Oct 2024 14:54:18 +0000

Hey folks! In my continued work with open-source projects, I recently came across Twenty CRM, an open-source CRM platform that has been making waves in the business world. Today, I’m going to walk you through how you can set up Twenty CRM in just a few clicks using Docker Compose. Whether you're self-hosting or setting up for production, this guide will show you how easy it is to get up and running with minimal effort.

What is Docker Compose?
Docker Compose is a tool that simplifies running multi-container Docker applications by defining services, networks, and volumes in a single docker-compose.yml file. This makes it perfect for deploying an application like Twenty CRM in a streamlined, easy-to-manage way.

Overview of the 1-Click Docker Compose Setup

Setting up Twenty CRM using Docker Compose is designed to be simple and efficient. Follow the steps in this guide to install and configure the CRM platform with minimal hassle.

However, before jumping in, make sure you’ve got the required system specifications and Docker tools installed. Let's walk through the steps to get you started!

System Requirements
Before we begin, ensure you meet the following system requirements:

RAM: At least 2GB of RAM is required. Insufficient memory can cause processes to crash.
Docker & Docker Compose: Make sure both Docker and Docker Compose are installed and up-to-date on your system.

Option 1: One-Line Script Installation
The quickest way to install Twenty CRM is by running a single command. This option is perfect for users who want a fast and easy setup.

Run this command to install the latest stable version:

bash <(curl -sL https://git.new/20)

To install a specific version or branch, use the following command, replacing x.y.z with your desired version number, and branch-name with the branch you want:

VERSION=x.y.z BRANCH=branch-name bash <(curl -sL https://git.new/20)

Option 2: Manual Setup
For users who prefer a more hands-on approach, follow these manual steps:

Step 1: Set Up the Environment File
Create an .env file to configure your environment variables.

Copy the example environment file to a new .env file in your working directory:

curl -o .env https://raw.githubusercontent.com/twentyhq/twenty/main/packages/twenty-docker/.env.example

Generate Secret Tokens by running this command four times to create unique strings:

openssl rand -base64 32

Update your .env file with the generated values:

ACCESS_TOKEN_SECRET=first_random_string
LOGIN_TOKEN_SECRET=second_random_string
REFRESH_TOKEN_SECRET=third_random_string
FILE_TOKEN_SECRET=fourth_random_string

Set the Postgres Password:

In the .env file, replace the placeholder POSTGRES_ADMIN_PASSWORD with a strong password:

POSTGRES_ADMIN_PASSWORD=my_strong_password

Step 2: Download the Docker Compose File
Download the docker-compose.yml file into your working directory:

curl -O https://raw.githubusercontent.com/twentyhq/twenty/main/packages/twenty-docker/docker-compose.yml

Step 3: Launch the Application
Start the Docker containers with:

docker-compose up -d

Step 4: Access the Application
Once the containers are running, open your browser and navigate to http://localhost:3000 to access Twenty CRM.

Configuration
Exposing Twenty CRM to External Access
By default, Twenty runs on localhost at port 3000. If you want to expose it to external access, you need to configure the SERVER_URL in your .env file.

Understanding the SERVER_URL
Protocol: Use http or https, depending on whether you have SSL configured.
Domain/IP: Set this to the domain name or IP address where your application will be accessible.
Port: Include the port number if you're not using the default ports (80 for http, 443 for https).

Examples:
Direct access without SSL:

SERVER_URL=http://123.45.67.89:3000
Access via domain with SSL:

SERVER_URL=https://mytwentyapp.com

Once updated, restart the containers for changes to take effect:

docker-compose down
docker-compose up -d

Troubleshooting
Unable to Log In
If you encounter login issues, try the following commands:

docker exec -it twenty-server-1 yarn
docker exec -it twenty-server-1 npx nx database:reset

Then, restart the containers:

docker-compose down
docker-compose up -d

Connection Issues Behind a Reverse Proxy
Make sure the SERVER_URL in your .env file matches the external access URL. Also, ensure your reverse proxy settings are properly configured to forward requests to the Twenty server, and restart both the reverse proxy and the Twenty containers.

Persistence and Data Volumes
The Docker Compose configuration automatically uses volumes to persist data for the database and server storage. This ensures your data remains intact, even if the containers are stopped or restarted.

Conclusion
Setting up Twenty CRM with Docker Compose is straightforward and efficient, whether you’re self-hosting or deploying in a production environment. By following the steps in this guide, you’ll have a fully functioning CRM in no time, with complete control over your data and infrastructure.

Give it a try, and experience Twenty CRM that grows with your business!

Thanks for reading! I hope you found this guide helpful. If you have any questions or run into issues, feel free to reach out to the Twenty CRM community for support. Cheers!

Twenty CRM: A Fresh Start for Modern Businesses

sateshcharan — Mon, 21 Oct 2024 14:22:24 +0000

Hey everyone! I've recently been diving into open-source projects during Hacktoberfest 2024, and I came across an incredible CRM platform that I just had to share. It’s called Twenty, and it’s truly a breath of fresh air for businesses in need of a streamlined CRM solution.

What is Twenty?

Two decades ago, CRM platforms transformed business operations by moving to the cloud, making it easier and more cost-effective to manage customer relationships. But over time, these platforms became bloated, expensive, and cumbersome. What started as a tool to streamline sales processes ended up overwhelming businesses with complexity.

Today, many companies feel stuck—struggling to customize their CRMs to fit their needs, manage ballooning costs, and work with convoluted interfaces. That’s where Twenty CRM steps in, offering a much-needed reset. It’s an open-source platform designed to bring back simplicity, control, and efficiency.

The Problem with Legacy CRMs
Over time, CRMs evolved beyond sales into other departments like finance, marketing, and customer support. However, this growth came at a cost:

Rising costs: Finance teams struggled with increasing expenses as vendors added more features.
Customization headaches: Software engineers spent weeks or even months tweaking CRM systems to fit unique business needs.
Data rigidity: Data engineers found it difficult to move data between systems, trapped by restrictive structures.
User frustration: Sales teams, the original CRM users, were slowed down by cluttered interfaces, turning CRMs into a chore rather than a tool.

Somewhere along the way, businesses lost control of these essential tools. But Twenty is here to change that.

Enter Twenty CRM: The Solution to Bloated CRMs
Twenty is a CRM platform built to empower businesses by giving them flexibility, control, and an intuitive user experience. Here’s why it stands out:

1. Open-Source Flexibility
Forget the old “build vs. buy” debate. With Twenty, you get the best of both worlds: the option to customize the platform as you see fit. Since it’s open-source, you can fork the project, adapt it to your needs, and even contribute to its growth alongside a global community of developers. No more waiting for vendors to release features—you control the roadmap.

2. Data-Centric Approach
Today’s businesses collect data from multiple sources. Instead of forcing you into rigid templates, Twenty lets you work with your data as it is. It seamlessly integrates with your existing data systems, giving you the freedom to visualize and interact with your data in a way that makes sense for your business.

3. Design-Driven Experience
Inspired by platforms like Notion, Twenty prioritizes design and user experience. Whether you’re managing a sales pipeline or tweaking backend workflows, the platform offers a clean, customizable interface that’s both functional and enjoyable. Developers and end users alike will find the experience seamless and intuitive.

Why Twenty is the Future of CRM
Twenty isn’t just another CRM platform—it’s a movement to bring control back to businesses. Here’s why it’s the future of CRM:

Ownership: With its open-source foundation, you’re in control of the features and updates. No more vendor lock-in.
Data at the core: Your data from sales, finance, marketing, and more is easily accessible and actionable.
Community-driven development: Thousands of developers are actively contributing, ensuring the platform evolves with the needs of modern businesses.
If you’re fed up with bloated, expensive CRM systems, now is the time to explore Twenty.

Getting Started with Twenty: A Quick Overview
Upon logging in, you’ll be greeted with an intuitive onboarding screen where you can set up your workspace. The navigation bar allows easy access to search, settings, and workspace management.

Twenty comes with pre-built models like:

People
Companies
Opportunities
Tasks
Notes

Let me walk you through how I manage invoices and tasks using Twenty.

Step 1: Create a Custom Data Model
To create an invoice model, head to the Settings panel and click on Data Model. You’ll then see an option to create a new object.

For singular, enter "invoice."
For plural, enter "invoices."
Add a description if needed and hit Save.

Twenty automatically adds essential fields like attachments, creation date, notes, and tasks, but you can customize it further by clicking Add Field.

Step 2: Manage Your Invoices
Once your data object is created, return to the dashboard and select Invoice.

You’ll be able to add new invoices with all the fields you specified earlier. Easily keep track of invoice details, saving you the hassle of endless client emails.

Conclusion
Twenty CRM offers a clean, flexible, and powerful solution to the cluttered CRM landscape. If you’re looking for a tool that will help you take control of your business, streamline your processes, and offer a superior user experience, I highly recommend giving it a try. You’ll find that Twenty transforms the way you manage customer relationships and data. Checkout TwentyCRM today!

Thanks for reading! If you found this helpful, don’t forget to like and support. Cheers!