DEV Community: Naman vyas

ShowDEV - We built a All-in-one AI command center for your products.

Naman vyas — Sun, 11 Aug 2024 20:47:37 +0000

Hey there, fellow devs! 👋 Are you building AI-powered applications? Struggling with managing multiple AI providers, optimizing costs, and keeping track of your prompts? We've got something exciting to share with you today!

My brother @vaibhavacharya (AI wizard) and I have been working on various AI applications for the past couple of years. During this time, we encountered numerous hurdles:

Juggling multiple AI provider APIs
Struggling with cost optimization
Managing and versioning prompts effectively
Lack of comprehensive analytics

These pain points weren't unique to us – we saw many developers facing similar issues. That's when we decided to create a solution.

Meet UltraAI.app

UltraAI.app is your new best friend in the world of AI development. It's an all-in-one AI command center designed to make your life easier and your applications smarter. Let's dive into what makes UltraAI.app special!

🌐 Multi-provider AI Gateway

Gone are the days of juggling multiple AI provider APIs. UltraAI.app offers a unified interface to access various AI providers through a single, OpenAI-compatible API. Whether you're using OpenAI, Anthropic, or any other supported provider, you can switch between them seamlessly without changing your code.

💾 Semantic Caching

Want to save up to 10x on your API costs? Our semantic caching has got you covered! Choose between simple and similarity caching, fine-tune the behavior for each API call, and set precise similarity levels for optimal results. It's like having a super-smart AI assistant that remembers previous conversations!

📊 Logs & Analytics

Make data-driven decisions faster with our comprehensive logs and analytics. Monitor your AI usage, track costs, and gain insights into your application's performance. It's like having a crystal ball for your AI operations!

📝 Prompts Manager

Managing and using dynamic prompts can be a headache. We've made it easy! With our Prompts Manager, you can store, version control, and efficiently manage your AI prompts. It's like having a well-organized library for all your AI conversations.

🛡️ Rate Limiting & Protection

Protect your product and prevent abuse with our built-in rate limiting feature. Set custom limits for each user, choose flexible time frames, and easily integrate it into your application. It's like having a bouncer for your AI party!

Why Choose UltraAI.app?

Simplicity: One API to rule them all. No more juggling multiple provider SDKs.
Cost-Effective: Save money with intelligent caching and optimized API usage.
Flexibility: Easily switch between AI providers without changing your code.
Insights: Make informed decisions with detailed logs and analytics.
Security: Protect your application with built-in rate limiting.

Getting Started is a Breeze!

Sign up for UltraAI.app (Psst... it's free during beta!)
Grab your API key from the dashboard.
Replace your existing OpenAI base URL with https://api.ultraai.app/v1.
Start coding with superpowers!

Here's a quick example in Python:

import json
from openai import OpenAI

client = OpenAI(
    api_key="your-ultraai-api-key",
    base_url="https://api.ultraai.app/v1"
)

completion = client.chat.completions.create(
    model=json.dumps({
        "models": ["openai:gpt-4", "anthropic:claude-2"],
        "cache": {
            "type": "similarity",
            "maxAge": 3600,
            "threshold": 0.8
        }
    }),
    messages=[{"role": "user", "content": "Hello, how are you?"}],
    user=json.dumps({
        "userId": "user123",
        "maxRequests": 100,
        "duration": "hour"
    })
)

Join the UltraAI Community

We're excited to see what you'll build with UltraAI.app! Have questions, feedback, or just want to chat about AI? We'd love to hear from you:

📚 Check out our documentation for detailed guides and API references.
📝 Read our blog posts for tips, tricks, and AI insights.
📅 Book a call with us to discuss your AI needs.
📧 Reach out to us at vaibhav@ultraai.app for any queries.

Ready to supercharge your AI development? Sign up for UltraAI.app today and join us on this exciting journey! 🚀

Happy coding, and may the AI be with you! 🤖✨

Debugging AI: Tools and Techniques for Troubleshooting AI Applications

Naman vyas — Sun, 11 Aug 2024 19:54:48 +0000

As AI applications become increasingly complex, debugging them can feel like finding a needle in a haystack. But fear not! In this post, we'll explore some effective strategies and tools for troubleshooting AI applications, with a special focus on how UltraAI.app can streamline your debugging process.

Common Challenges in AI Debugging

Before we dive into solutions, let's identify some common challenges:

Lack of transparency: AI models, especially deep learning ones, can be black boxes.
Reproducibility issues: AI behavior can be inconsistent due to randomness in training or inference.
Data-related problems: Issues with input data can lead to unexpected outputs.
Performance bottlenecks: AI models can be computationally expensive, leading to slow response times.
Integration complexities: AI services often involve multiple components and APIs.

General Debugging Strategies for AI Applications

1. Implement Comprehensive Logging

Detailed logging is your first line of defense. Log everything from input data and model parameters to intermediate outputs and final results. This helps in tracing the flow of data and identifying where things might be going wrong.

Pro tip: Use UltraAI.app's logging feature to automatically capture detailed logs for all your AI interactions across different providers. This centralized logging makes it easier to spot patterns and anomalies.

2. Use Visualization Tools

Visualizing your data and model outputs can provide insights that raw numbers can't. Tools like TensorBoard for TensorFlow or Weights & Biases can help you visualize model architectures, training progress, and output distributions.

3. Implement A/B Testing

When making changes to your AI model or application, use A/B testing to compare the performance of different versions. This helps isolate the impact of specific changes.

UltraAI.app tip: Our multi-provider gateway makes it easy to run A/B tests across different AI models or providers. Simply specify multiple models in your API call, and we'll handle the rest!

4. Utilize Explainable AI Techniques

Techniques like SHAP (SHapley Additive exPlanations) or LIME (Local Interpretable Model-agnostic Explanations) can help you understand how your model is making decisions. This is particularly useful for identifying biases or unexpected behaviors.

5. Monitor Performance Metrics

Keep a close eye on key performance metrics like response time, error rates, and resource utilization. Sudden changes in these metrics can indicate underlying issues.

UltraAI.app advantage: Our built-in analytics dashboard provides real-time insights into your AI application's performance across all providers. Spot trends and anomalies at a glance!

6. Implement Robust Error Handling

Design your application to gracefully handle and report errors. This includes not just model errors, but also issues with data preprocessing, API calls, and result parsing.

7. Use Semantic Caching for Faster Debugging

Caching can significantly speed up the debugging process by reducing the need to recompute results for the same or similar inputs.

UltraAI.app feature spotlight: Our semantic caching capability not only speeds up your application but also makes debugging faster. You can quickly retrieve past results for similar inputs, helping you isolate issues more effectively.

Tools for AI Debugging

Integrated Development Environments (IDEs): PyCharm, Visual Studio Code with Python extensions
Debugging Libraries: pdb for Python, debug for Node.js
Profiling Tools: cProfile for Python, Node.js built-in profiler
Model Inspection Tools: Netron for visualizing model architectures
API Testing Tools: Postman, cURL for testing HTTP requests

UltraAI.app as your debugging companion: While these tools are great, UltraAI.app brings everything together in one place. Our platform provides:

Centralized logging across all AI providers
Real-time performance analytics
Easy A/B testing capabilities
Semantic caching for faster iterations

Best Practices for AI Debugging

Start with a simple model: Begin with a baseline model and gradually increase complexity.
Use synthetic data: Create test cases with known outputs to verify model behavior.
Implement unit tests: Test individual components of your AI pipeline separately.
Version control everything: Not just your code, but also your data and model versions.
Document your debugging process: Keep track of what you've tried and the results.

Conclusion

Debugging AI applications can be challenging, but with the right strategies and tools, it becomes much more manageable. By implementing comprehensive logging, utilizing visualization tools, and leveraging platforms like UltraAI.app, you can significantly streamline your debugging process.

Remember, effective debugging is not just about fixing errors—it's about gaining deeper insights into your AI application's behavior and performance. With UltraAI.app, you get a powerful ally in your quest for robust, high-performance AI applications.

Ready to take your AI debugging to the next level? Sign up for UltraAI.app today and experience the difference!

Happy debugging! 🐛🔍🤖

From OpenAI to Anthropic: Switching AI Providers Without Breaking Your Code

Naman vyas — Sat, 10 Aug 2024 21:38:02 +0000

In the rapidly evolving world of AI, having the flexibility to switch between different AI providers can be a game-changer for your applications. Whether you're looking to optimize costs, experiment with different models, or ensure reliability through redundancy, the ability to seamlessly switch between providers like OpenAI and Anthropic is crucial. In this blog post, we'll explore how to make this switch without breaking your code, and introduce a tool that makes this process even easier.

The Challenge of Switching AI Providers

Traditionally, switching between AI providers like OpenAI and Anthropic would require significant code changes. Each provider has its own SDK, authentication methods, and API structure. This can lead to:

Extensive code refactoring
Potential downtime during the switch
The need to maintain multiple codebases for different providers

But what if there was a way to switch providers with minimal code changes? Enter UltraAI.app, your all-in-one AI command center.

Introducing UltraAI.app

UltraAI.app provides a unified API that's compatible with multiple AI providers, including OpenAI and Anthropic. By using UltraAI, you can switch between providers with just a simple configuration change, without altering your core application code.

Let's look at how this works in practice.

Code Example: OpenAI to Anthropic Switch

Here's how you might typically use OpenAI in your Python code:

from openai import OpenAI

client = OpenAI(api_key="your-openai-api-key")

response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What's the capital of France?"}
    ]
)

print(response.choices[0].message.content)

Now, let's see how you can use UltraAI to easily switch to Anthropic:

from openai import OpenAI

client = OpenAI(
    api_key="your-ultraai-api-key",
    base_url="https://api.ultraai.app/v1"
)

response = client.chat.completions.create(
    model=json.dumps({
        "models": ["anthropic:claude-2", "openai:gpt-3.5-turbo"]
    }),
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What's the capital of France?"}
    ]
)

print(response.choices[0].message.content)

As you can see, the core structure of the code remains the same. The key differences are:

We're now using the UltraAI base URL.
We're specifying the model as a JSON string that includes both Anthropic and OpenAI models.

With this setup, UltraAI will first attempt to use Anthropic's Claude 2 model. If that fails for any reason, it will automatically fall back to OpenAI's GPT-3.5-turbo.

Benefits of Using UltraAI for Provider Switching

Minimal Code Changes: As demonstrated, switching providers requires only minor configuration changes.
Automatic Fallbacks: UltraAI can automatically switch to backup providers if the primary one fails.
Unified Billing and Analytics: Track usage across all providers in one place.
Consistent API: Use the same API structure regardless of the underlying provider.
Cost Optimization: Easily switch to the most cost-effective provider for your needs.

Advanced Features

UltraAI offers more than just easy provider switching. Here are some advanced features you can leverage:

Semantic Caching

Reduce API calls and costs with intelligent caching:

response = client.chat.completions.create(
    model=json.dumps({
        "models": ["anthropic:claude-2", "openai:gpt-3.5-turbo"],
        "cache": {
            "type": "similarity",
            "maxAge": 3600,
            "threshold": 0.8
        }
    }),
    messages=[{"role": "user", "content": "What's the capital of France?"}]
)

Rate Limiting

Protect your application from abuse with built-in rate limiting:

response = client.chat.completions.create(
    model="anthropic:claude-2",
    messages=[{"role": "user", "content": "What's the capital of France?"}],
    user=json.dumps({
        "id": "user123",
        "maxRequests": 100,
        "duration": "hour"
    })
)

Conclusion

Switching between AI providers doesn't have to be a headache. With UltraAI.app, you can easily switch between OpenAI, Anthropic, and other providers without significant code changes. This flexibility allows you to optimize your AI usage, experiment with different models, and build more resilient applications.

Ready to simplify your AI integrations? Sign up for UltraAI.app today and experience the freedom of provider-agnostic AI development!

Remember, the future of AI is flexible, and with UltraAI, you're always ready for what's next. Happy coding!

The Ultimate Guide to Managing AI Prompts for Developers

Naman vyas — Sat, 10 Aug 2024 21:31:11 +0000

The Ultimate Guide to Managing AI Prompts for Developers

As AI becomes increasingly integral to software development, managing prompts effectively has become a crucial skill for developers. In this guide, we'll explore best practices for prompt engineering and introduce you to UltraAI.app, a game-changing tool for AI prompt management.

Understanding Prompt Engineering

Prompt engineering is the art and science of crafting input prompts to elicit desired outputs from AI models. It's a critical skill for developers working with large language models (LLMs) like GPT-3, GPT-4, or Claude.

Best Practices for Prompt Engineering

1. Be Specific and Clear

Clarity is key when crafting prompts. Be as specific as possible about what you want the AI to do.

Bad Example: "Write about dogs."
Good Example: "Write a 200-word paragraph about the history and characteristics of Golden Retrievers."

2. Provide Context

Give the AI model necessary background information to generate accurate responses.

Example: "You are a financial advisor speaking to a 25-year-old who has just started their first job. Explain the importance of starting to save for retirement early."

3. Use Examples

Provide examples of the kind of output you're looking for, especially for complex tasks.

Example: "Translate the following English phrases to French. Here's an example:
Input: 'Hello, how are you?'
Output: 'Bonjour, comment allez-vous?'

Now translate:

'Where is the nearest restaurant?'
'I love to travel.'"

4. Break Complex Tasks into Steps

For complicated tasks, break them down into smaller, manageable steps.

Example: "Let's write a short story. Follow these steps:

Generate three character names and brief descriptions.
Create a setting for the story.
Outline a basic plot with a beginning, middle, and end.
Write the story in 500 words based on these elements."

5. Use Control Statements

Incorporate control statements to guide the AI's behavior.

Example: "Analyze the following text for sentiment. Respond ONLY with 'Positive', 'Negative', or 'Neutral'. Text: 'The new restaurant in town has great food, but the service is slow.'"

6. Iterate and Refine

Don't expect perfect results on the first try. Iterate on your prompts, refining them based on the outputs you receive.

7. Consider Ethical Implications

Always consider the ethical implications of your prompts. Avoid generating harmful, biased, or inappropriate content.

Managing Prompts with UltraAI.app

While these best practices are crucial, managing prompts across multiple projects and team members can be challenging. This is where UltraAI.app comes in, offering a robust solution for prompt management.

Key Features of UltraAI.app for Prompt Management

Centralized Prompt Storage: Store all your prompts in one place, accessible to your entire team.
Prompt Templates: Create reusable prompt templates to ensure consistency across your projects.
Dynamic Variables: Use variables in your prompts for easy customization without changing the core prompt structure.
Performance Analytics: Track the performance of different prompts to identify which ones work best.
Collaboration Tools: Share prompts with team members and collaborate on prompt refinement.
Integration with Multiple AI Providers: Use your prompts with various AI providers through UltraAI.app's unified API.

Using UltraAI.app for Effective Prompt Management

Here's a quick example of how you can use UltraAI.app to manage your prompts:

import json
from openai import OpenAI

client = OpenAI(
    api_key="your-ultraai-api-key",
    base_url="https://api.ultraai.app/v1"
)

completion = client.chat.completions.create(
    model=json.dumps({
        "models": ["openai:gpt-4", "anthropic:claude-2"],
        "cache": {
            "type": "similarity",
            "maxAge": 3600,
            "threshold": 0.8
        }
    }),
    messages=[{"role": "user", "content": "Hello, how are you?"}],
    user=json.dumps({
        "userId": "user123",
        "maxRequests": 100,
        "duration": "hour"
    })
)

In this example, we're using a prompt template stored in UltraAI.app with the ID "customer-support-prompt-v2". We're passing in variables for the product name and customer name, which will be inserted into the prompt template.

This approach allows you to:

Reuse prompts across your application
Easily update prompts without changing your code
Maintain consistency in your AI interactions
Track the usage and performance of different prompts

Conclusion

Effective prompt engineering and management are key to successful AI development. By following these best practices and leveraging tools like UltraAI.app, you can create more efficient, consistent, and powerful AI-driven applications.

Ready to take your prompt management to the next level? Sign up for UltraAI.app today and experience the difference that professional prompt management can make in your AI development workflow.

Remember, the art of prompt engineering is continually evolving. Stay curious, keep experimenting, and don't hesitate to share your experiences with the community. Happy prompting!

Introducing UltraAI.app — All-in-one AI command center for your product.

Naman vyas — Sun, 28 Jul 2024 19:31:07 +0000

Meet UltraAI.app

🌐 Multi-provider AI Gateway

💾 Semantic Caching

📊 Logs & Analytics

📝 Prompts Manager

🛡️ Rate Limiting & Protection

Why Choose UltraAI.app?

Simplicity: One API to rule them all. No more juggling multiple provider SDKs.
Cost-Effective: Save money with intelligent caching and optimized API usage.
Flexibility: Easily switch between AI providers without changing your code.
Insights: Make informed decisions with detailed logs and analytics.
Security: Protect your application with built-in rate limiting.

Getting Started is a Breeze!

Sign up for UltraAI.app (Psst... it's free during beta!)
Grab your API key from the dashboard.
Replace your existing OpenAI base URL with https://api.ultraai.app/v1.
Start coding with superpowers!

Here's a quick example in Python:

import json
from openai import OpenAI

client = OpenAI(
    api_key="your-ultraai-api-key",
    base_url="https://api.ultraai.app/v1"
)

completion = client.chat.completions.create(
    model=json.dumps({
        "models": ["openai:gpt-4", "anthropic:claude-2"],
        "cache": {
            "type": "similarity",
            "maxAge": 3600,
            "threshold": 0.8
        }
    }),
    messages=[{"role": "user", "content": "Hello, how are you?"}],
    user=json.dumps({
        "userId": "user123",
        "maxRequests": 100,
        "duration": "hour"
    })
)

Join the UltraAI Community

We're excited to see what you'll build with UltraAI.app! Have questions, feedback, or just want to chat about AI? We'd love to hear from you:

📚 Check out our documentation for detailed guides and API references.
📝 Read our blog posts for tips, tricks, and AI insights.
📅 Book a call with us to discuss your AI needs.
📧 Reach out to us at vaibhav@ultraai.app for any queries.

Ready to supercharge your AI development? Sign up for UltraAI.app today and join us on this exciting journey! 🚀

Happy coding, and may the AI be with you! 🤖✨

Control a 3D Model with Your Phone: A React, Three.js, and Socket.io Project 🚀

Naman vyas — Wed, 26 Apr 2023 17:22:22 +0000

As a fan of 3D models and technology, I wanted to create a website that allows you to control a 3D model using your phone's movements on a local network. Here's how I did it

First, I found a 3D model of a phone online and downloaded it. Then, I used Three.js to display the model on the screen, React.js for the frontend, and Express Node for the backend. I utilized Socket.io to transmit data on the local network.

here is the result:

To sync the 3D model movement with the phone, I used the phone's gyro sensor data and transmitted it to the phone using Socket.io. However, I ran into a problem where I wasn't able to run the application on a local IP due to Chrome's security rules not allowing sensor data on an unsecured site. After some research, I forwarded my PC port to my Android device to access my page as localhost.

If you're interested in more projects like this, be sure to follow me on Twitter where I share my latest tech explorations!

https://twitter.com/gitrevert/status/1651234806783528960

I tried making this reflective UI using HTML CSS and Javascript

Naman vyas — Tue, 07 Mar 2023 17:53:40 +0000

Have you ever seen a website with a reflective user interface?

Recently, I decided to take on the challenge of creating a reflective UI using only these three technologies: HTML, CSS and JavaScript. And after some experimentation and tweaking, I'm happy to share my results with you all.

you can check it out at: https://demo-gg.vercel.app/

Also it you like it please follow me on Twitter: @gitrevert

// Detect dark theme var iframe = document.getElementById('tweet-1633057413312987136-309'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1633057413312987136&theme=dark" }

Created A AI-Powered Solution For E-commerce Products

Naman vyas — Thu, 02 Feb 2023 16:57:24 +0000

Hello everyone 👋

Trying to come up with the ideal title, description and other information for your products is taking up a lot of your time. Do you find it difficult to create enticing and comprehensive product descriptions that encourage clients to make purchases? So stop looking now! Writing product descriptions no longer needs to be a burden thanks to our AI-powered tools.
Link: - Aiproducttools.com

Why?

We noted that our friend, who works in online sales, struggles with the same thing. He puts a lot of thought and work into creating the best product title, description, and other information for his products. This inspired Vaibhav and Me to develop a method that would reduce the time and work necessary for product descriptions while maximizing their effectiveness.

To assist online sellers like our friend, we created the AI-powered product tools. It was our goal to develop a platform where everyone can find the answer they require for their online selling business. With the help of this tool, anyone can quickly and easily create high-quality product descriptions, saving time and effort while still delivering outcomes that will increase sales.

Tech Stack

Remix.run
OpenAI
TailwindCSS
Cockroachdb
Prisma

Future goals

Product image enhancer
Product banner generator
Product ad creator
And many more

Thanks for reading 😊.

Give our product a try - Aiproducttools.com
And drop your suggestion below

Avoiding Common Pitfalls when Working with React JS 🚫

Naman vyas — Wed, 07 Dec 2022 16:39:48 +0000

React JS is a powerful and popular JavaScript library for building user interfaces, but like any technology, it has its own set of challenges and potential pitfalls. In this blog post, we'll look at some of the most common mistakes and pitfalls to avoid when working with React JS in order to help you get the most out of this powerful tool.

💻 Using React as a One-Size-Fits-All Solution

One of the most common mistakes that people make when working with React is trying to use it as a one-size-fits-all solution. React is a powerful tool, but it's not suitable for every situation. In particular, React is best suited for building user interfaces, and it's not as well-suited for tasks like data processing or routing. If you try to use React for tasks that it's not well-suited for, you may run into performance issues or other problems.

🧠 Not Understanding How React Works

Another common mistake is trying to use React without a thorough understanding of how it works. React uses a concept called the virtual DOM, which allows it to efficiently update the user interface based on changes in the underlying data. If you don't understand how the virtual DOM works, you may run into problems when trying to manage state or update the user interface.

🔨 Ignoring the Ecosystem of Tools and Libraries

Additionally, many people make the mistake of trying to use React without learning about its ecosystem of tools and libraries. React is just a piece of the puzzle, and in order to build a complete application, you'll need to use a range of tools and libraries like Redux for state management, React Router for routing, and many others. If you don't take the time to learn about these tools and how to use them properly, you may run into difficulties when building your React applications.

🗂️ Poor Code Organization

Finally, one of the most common pitfalls when working with React is poor code organization. React applications can quickly become complex, with many different components, state changes, and interactions between different parts of the application. If you don't take the time to organize your code and structure it properly, your application can quickly become difficult to maintain and debug.

In conclusion, React JS is a powerful tool for building user interfaces, but it's important to avoid common pitfalls and mistakes in order to get the most out of it. By understanding the limitations of React, learning about its ecosystem of tools and libraries, and organizing your code properly, you can avoid many of the common problems and challenges when working with this powerful JavaScript library.

Thank you fam for reading!!!
Have a great day 😊

Ideaas: A simple platform where lazy people can share their ideas with you and you can build them.

Naman vyas — Sat, 19 Nov 2022 04:08:52 +0000

Introduction

do you have an idea that you can not build, share them with the community.
you can check the product here👉: ideaas.co

Why?

I had one friend who always had ideas but not the skill to build them. So, he used to tell me the ideas and I used to build them. Then I thought, why not create a community where people can share their idea, discuss and then build them.

Future

I'm going to add the option to sell an idea if you have more than a idea, such as a case study or some mvp.
Sorting and tags
Profile edit

Tech stack

Remix Run
TailwindCSS
cockroachDB
Prisma ORM

Thank you 😊

Jobilist: Side project to product

Naman vyas — Sun, 15 May 2022 07:44:18 +0000

Hello everyone👋

We published our side project public a few days ago after seeing some issues on job boards. We got a lot of positive feedback on it, so we're going to turn it into a side business.

Website Link : https://jobilist.com
GitHub: https://github.com/jobilist/jobilist
ProductHunt: https://www.producthunt.com/posts/jobilist

What is Jobilist:
It is simple and straightforward job board for both job seekers and employers. It is affordable, beautiful and opensource.

How it started
We were looking for a job and visited a number of job boards, but we noticed that they were all bulky and displayed useless information, were spammed with advertisements, and so on. So we decided to build a basic and effective job board.
And we launched it a few days ago in the community, and we've gotten a lot of positive feedback in the last few days; today, we have around 1000+ daily visitors and 50+ active job postings on our job board. After seeing all of this, we decided to transform this project into a product at a cheap price, as the prices on other job boards are expensive.

Thank you!

ShowDEV - A open source job Board

Naman vyas — Wed, 04 May 2022 07:20:24 +0000

Hello everyone👋

We are very excited to introduce our first product to the community. It is simple and straightforward job board for both job seekers and employers. It is affordable, beautiful and opensource.

Website Link : https://jobilist.com
GitHub: https://github.com/jobilist/jobilist
ProductHunt: https://www.producthunt.com/posts/jobilist

Build With
Remix.run
Prisma(Postgresql)
Railway.app

Thank you!