Full-Stack Software Engineer – AI-Powered Search Assistant Development

We are an early-stage company building a web-based AI search assistant similar to Perplexity. ai, but directed at the German market. Our goal is to create a “conversational answer engine” that users can query naturally and receive accurate, source-cited answers in real time. We’re looking for a highly capable Full-Stack Developer who can independently build an MVP of this product from the ground up, leveraging OpenAI’s API and other tools. This role offers the opportunity to lead the development of an ambitious AI-driven web app – implementing everything from the front-end UI to the back-end services – and truly own the entire tech stack. If you’re passionate about LLMs, information retrieval, and creating impactful user experiences, and you thrive in an autonomous environment, we want to hear from you!

Scope & Responsibilities:
As the lead (and only) developer, you will be responsible for end-to-end development of our AI search assistant web application. This includes:

- Designing and implementing the core application architecture: You will make key decisions on the tech stack and overall architecture to integrate web search results with an LLM (via OpenAI’s API) and present answers with citations. Expect to set up both the client-side and server-side components required for a responsive, real-time Q&A system.

- Developing the conversational UI: Build a sleek, intuitive web interface where users can ask questions and get streaming answers. This involves creating the chat dialog layout, implementing message streaming (so answers appear word-by-word), displaying source footnotes, and adding interactive elements like suggested follow-up questions and focus mode toggles. You’ll work with HTML/CSS/TypeScript (likely using React and possibly Next.js) to make a highly dynamic single-page application that is also mobile-responsive.

- Implementing context and memory: Ensure that the application supports multi-turn conversations. Users should be able to ask a question, get an answer, and then ask a follow-up in the same thread with the system remembering context. This will require maintaining conversation state on the client and server, and managing how past Q&As are fed into the model for context.

- Integrating real-time web search and data retrieval: Connect the application to a web search API (e.g. Bing or Google) to retrieve relevant results for each user query. You will write the logic to take a user’s question, issue search requests, and then fetch the content of the top results (scraping the webpage text). This includes parsing HTML or PDF content to extract clean text, and possibly using techniques to identify the most relevant passages. The goal is to create a retrieval pipeline that supplies the language model with accurate, up-to-date information for it to formulate answers.

- Orchestrating the AI answer generation: Using OpenAI’s API (or similar LLM services), you will compose prompts that combine the user’s question and the retrieved content, and request a completion. You’ll need to instruct the model to produce answers in a specific format (concise paragraphs with [1], [2] style citations). This involves prompt engineering and testing to get the desired results. You will handle the API interaction on the back-end, including streaming the response back to the frontend so the user can see the answer materialize in real time.

- Citation alignment and source handling: Develop a method to attach sources to the AI’s answer. For MVP, this could involve feeding the model labeled source snippets so it naturally outputs citations, or implementing a post-processing step that maps statements in the answer back to the source texts. You are responsible for ensuring that each citation [1], [2] corresponds to the correct URL and that clicking it will show the reference. This feature is crucial for user trust, so part of your role is to fine-tune how sources are selected and displayed.

- Building user features: accounts, history, and preferences: Implement a basic user authentication system (users can sign up, log in/out) and create a personal area where users can see their past questions and answers (conversation history). This “Library” of saved threads should allow users to reopen a conversation from a previous session. You will design a small database (or use a cloud service) to store user profiles, query history, and possibly favorited or pinned conversations. Additionally, support an **Incognito mode** where queries are not saved to history, and ensure user privacy preferences are respected.

- Advanced features and settings: Incorporate additional product features such as the *Focus Mode* filters (e.g. the ability to restrict a query to academic sources or a specific website) and suggested follow-up questions generation. For focus modes, you might implement UI options and modify the search/query pipeline accordingly (for example, add `site:edu` for Academic focus, or call a different content source for a specific mode). For suggested questions, you may either use the LLM to generate related questions or pre-configure some logic to propose them – but you will own delivering this as part of the answer view. You’ll also implement the indication of different answer modes (for instance, if a “Pro” mode with GPT-4 is active, display an indicator in the UI).

- File upload and analysis (optional for MVP): Plan and possibly implement the ability for users to upload files (PDFs, text, etc.) and ask questions about them. This involves back-end file handling, text extraction from documents, and integrating that text into the answer generation pipeline. While this is a stretch goal for the MVP, you should design the system in a way that adding file Q&A is feasible (for example, a user could attach a file, and your back-end would parse it and treat its content as additional context).

- Pro subscription support: Implement a mechanism to differentiate free vs. paid users. This includes enforcing limits (e.g. number of queries per day, or access to certain features/models) for free users and lifting those for Pro users ([Perplexity Pricing: Is It Worth It in 2025? | Team-GPT (for example, a free user sees a “Upgrade to use GPT-4” prompt after their quota, whereas a Pro user’s requests route to the premium model). If applicable, integrate a payment system to handle upgrades, or at least a system to manually upgrade accounts in the database for testing. Over time, you would be responsible for managing subscription verification, payment webhooks, etc. (Note: while we won’t launch payments in the initial MVP, the design should accommodate adding it.)

- Performance optimization and scalability: Since this application performs multiple external calls per query (search, fetch pages, call AI model), efficiency is key. You will optimize the pipeline – for example, fetching and processing search results in parallel, caching results where possible, and streaming output as soon as it’s available – to minimize user wait time. As the sole engineer, you’ll also be thinking ahead about scaling: how to structure the app to handle many simultaneous users. This might involve setting up background workers for heavy tasks or optimizing database queries. Part of your responsibility is writing clean, modular code and possibly tests for critical components to ensure reliability as we grow.

- Deployment and DevOps: Initially, you’ll deploy the MVP on a cloud platform so that testers/users can access it via browser. You will handle everything from configuring the hosting environment, setting up the database, to deploying the front-end and back-end code. Ensuring environment variables (API keys, secret tokens) are properly managed is under your purview. You’ll also implement basic monitoring and error logging. Essentially, you maintain the live service end-to-end. If any issues arise in production (e.g. an API key quota is exceeded or a bug crashes the site), you are the first (and only) line of defense to debug and fix it. This ops responsibility also means being mindful of costs – using efficient solutions and perhaps scheduling certain heavy jobs (like refreshing any index) during off-peak times or using free tiers where possible, given our limited resources.

Required Skills & Experience:

- Full-Stack Web Development: 2+ years experience (or equivalent proficiency) building web applications. You should be comfortable with front-end frameworks (preferably React + TypeScript). Experience with Next.js or similar SSR frameworks is a big plus ([Frontend Software Engineer - Perplexity | Built In](Upgrade to see actual info=,paced)). You have a solid grasp of HTML/CSS, and can create responsive, accessible user interfaces. On the back-end, you have worked with Node.js/Express or Python/Flask (or similar) to build APIs. You understand REST principles and have designed endpoints from scratch.

- Integrating External APIs: Proven ability to work with third-party APIs and SDKs. You’ve used APIs to fetch data from external services, handled authentication (API keys, OAuth), and parsed JSON/XML responses. (Specific experience with search APIs or social media APIs is a bonus.) You should be comfortable reading API documentation and using tools like Postman or curl for testing. In this project, you’ll be integrating the OpenAI API and a search engine API – familiarity with either/both is highly desirable.

- Working with AI/LLM Technologies: Hands-on experience with language models or NLP is required. This could be through OpenAI’s GPT-3/4, other cloud AI services, or open-source libraries. You should understand how to construct a prompt and handle model outputs. Experience implementing a **Retrieval-Augmented Generation** workflow would set you apart – for example, if you’ve used frameworks like LangChain or built a chatbot that references a knowledge base. At minimum, you should be eager and able to learn how to effectively use LLM APIs in an application (handling token limits, formatting answers, etc.). Knowledge of embedding models and vector databases is a plus, as our app will likely use semantic search for relevant info.

- Backend Architecture & Data Management: Strong skills in designing scalable back-end systems. You can set up a database (SQL or NoSQL) and write queries or use an ORM to interact with it. You’ve implemented user authentication and understand security best practices (password hashing, preventing injection attacks, secure session management). Experience with managing user data like profiles, preferences, and usage logs is important. You should also be adept at server-side logic – e.g., orchestrating multiple calls within a single request cycle and handling asynchronous operations. Given the need for real-time streaming, knowledge of how to implement streaming responses (using HTTP streaming or WebSocket protocols) is required. You have likely built features like chat or live updates before, or can demonstrate understanding of how to implement them (polling vs. push, etc.).

- Parsing and Data Extraction: You need the ability to programmatically handle web content – for example, using regex or HTML parsing to extract text from web pages. If you have experience with web scraping (even just building a script to scrape some site), that’s ideal. Familiarity with libraries or tools to extract text from PDFs and other document formats will be useful (e.g., pdf.js, PyPDF, or other parsing tools). Basically, you should be resourceful in converting unstructured data (HTML, documents) into structured text our AI can use.

- DevOps and Deployment: Demonstrated experience in deploying applications on the web. You should be able to set up a production environment (Linux server or cloud PaaS) and deploy code updates. Knowledge of Docker, CI/CD pipelines, and cloud services (AWS, GCP, or Azure) is beneficial. You should understand how to monitor application performance and logs. Since you’ll own the deployment, familiarity with DNS, SSL, and basic networking for a web app is expected. If you have experience optimizing apps for performance (caching strategies, load balancing, CDNs), mention it – we will eventually need to scale.

- Independent Problem-Solving: This role is highly autonomous – the ideal candidate has a track record of building projects end-to-end or working independently with minimal supervision. You should be comfortable taking high-level goals and translating them into a technical plan. Strong troubleshooting skills are a must – when something breaks (whether it’s an API not responding or a UI glitch), you systematically debug and resolve it. You manage your time effectively and can make progress without daily oversight. Prior experience in a startup or solo development of a product is a huge plus.

- Communication and Collaboration: While you’ll be the sole developer, you won’t work in complete isolation – you’ll be collaborating with the founder/product manager on requirements and with early users for feedback. You should be able to communicate technical choices and trade-offs clearly. Being receptive to feedback and able to explain complex tech in simple terms are valued. Also, since you own the tech, you might occasionally coordinate with external support (e.g., contacting an API provider or community when issues arise), so professionalism in communication is important.

Preferred Skills (Nice-to-Haves):

- UX/UI Design Sensibilities: Ability to craft an appealing UI without a dedicated designer. If you have an eye for detail in user interfaces and can mimic the polish of modern chat apps, that’s a big advantage. Experience with Figma or designing your own front-end components will help, as we want the product to feel on par with polished competitors.

- Experience with AI chat or search applications: If you’ve previously built a chatbot, semantic search engine, or any project that involved Q&A over documents, please let us know. Familiarity with the challenges of citations in AI answers or multi-turn dialogue management would let you hit the ground running.

- Knowledge of Open-Source LLMs and AI Stack: Down the road, we may explore using open-source models (like LLaMA derivatives) to reduce costs or for on-prem deployments. Experience with machine learning frameworks (PyTorch, TensorFlow) or having fine-tuned a model would be a bonus (though not required for initial work). Similarly, knowledge of running models on GPUs, using libraries like Hugging Face Transformers, or employing retrieval libraries (Haystack, etc.) could be useful.

- Cloud Architecture & Scalability: If you have experience designing systems that scaled to thousands of users, it’s a plus. This could include setting up task queues (e.g. Celery, RabbitMQ) for background processing, using Redis for caching, or scaling databases. Any DevOps skills like Terraform, Kubernetes, etc., are not required for MVP but could become relevant as we grow.


Please send your resume, a brief note about why you’re interested, and examples of relevant projects (e.g., links to projects or code), and please include a link to your GitHub. Highlight any experience with full-stack development or AI projects. We’re looking for someone who can demonstrate the initiative and skill to drive this project to completion largely solo. If that sounds like you, reach out!Join us in building the next-generation AI answer engine for Germany!

Please include your contact information in your application, including your WhatsApp/Telegram number and your email.