In a world where technology continues to reshape businesses, we’ve all heard about chatbots, AI assistants, and the magic of ChatGPT. But what if you could do so much more than just type questions into a chatbot window? What if you could build an internal tool—powered by advanced AI, vector embeddings, and knowledge retrieval—that streamlines your company’s workflows and slashes client onboarding times from 30 days to less than a week?
That’s precisely what we did. And the best part? I’m still pretty new to coding. From day one, I used AI coding assistants like Cursor and Claude to create a modern application in Next.js and TypeScript, showing how accessible AI-driven development has become. In this write-up, I’ll walk you through the journey, the core technologies we used, how we initially relied on n8n and custom GPTs, and how any business (even with a small dev team or a newbie coder) can harness AI to build powerful internal applications.
Our First Step: n8n and Custom GPT
Before building a full-blown AI-powered web application, we discovered n8n—a popular visual workflow builder with a node-based interface. It primarily works with JSON and JavaScript, allowing you to set up intricate API calls without writing too much code. We connected n8n to the OpenAI API and integrated database retrieval and web scraping actions.
Initially, this simplified a lot of our processes:
- Automated Workflows: We could visually piece together steps like “fetch data from our CRM,” “send it to OpenAI,” and “save the result to the database.”
- Basic Web Scraping: We created nodes that scraped relevant websites for quick research tasks, extracting the text into JSON for further processing.
- Customized GPT: We uploaded our documentation into ChatGPT (the “custom GPT” feature) to create specialized bots that answered specific internal questions.
This approach did wonders for our efficiency. We saw immediate improvements in how quickly our team could access relevant information. However, we hit several limitations when relying solely on custom GPT for larger projects:
- Account & Cost Limitations: Each user needed a ChatGPT Plus account ($20/month), which adds up for larger teams.
- Document Upload Limits: Custom GPT typically limits the number of files you can upload at once (10 or 20, depending on when you’re reading this). That’s not nearly enough for a robust internal knowledge base.
- Context Resets: Every time you open a new window, you lose the prior setup and must re-prompt it (repeatedly uploading documentation can become tedious).
- Granularity Issues: While custom GPT offered a quick solution, it wasn’t super granular. We wanted more precise agent selection (like “Google Ads Specialist” vs. “Facebook Ads Specialist”) and better retrieval capabilities.
Seeing how effective n8n and custom GPT could be, despite their limitations, inspired us to build something even more robust. That’s where our new AI-powered app comes in. Not only does it incorporate all the best parts of n8n’s workflow automation and GPT-like assistance, it also offers a structured agent selector, advanced vector-based retrieval, and unlimited capacity for internal documents.
Why We Built a Dedicated Internal AI Tool
If you’re running a business that deals with client onboarding—especially one involving lots of documentation, knowledge sharing, or compliance steps—you know how complicated and time-consuming the process can be. We were no different: Our onboarding process took around 30 days, largely because each client needed personalized support, and we had to reference huge amounts of internal data to tailor the experience for them.
We wanted to fix this. Our goal was simple:
- Faster Access to Information: Make it easier for our internal team to locate, reference, and share client-related information.
- Streamlined, Standardized Tasks: Automate repetitive tasks while still allowing for individualized client care.
- Better Knowledge Utilization: Use the wealth of internal data to improve decision-making and reduce the learning curve for new employees.
Enter our new AI-powered application. Within weeks, we transformed our manual processes and reduced onboarding to first ads launching from 20-30 days to under 7 days. Now, our staff and (soon) mastermind students have access to a tool that provides quick insights, automated data retrieval, and even web research capabilities—without the file and account limitations we faced using custom GPT alone.
The AI-Driven Development Journey
I’m particularly proud of how this entire tool was primarily built through AI-assisted coding. I started with minimal coding experience—just the basics of JavaScript and React. Thanks to AI coding assistants like Cursor and Claude, I could quickly spin up prototypes, debug errors, and refine my application without getting bogged down in the details.
The technology stack we ended up using includes:
- Next.js with TypeScript for the frontend and backend APIs.
- Vercel AI SDK for powering AI interactions.
- A vector database (through Supabase) to store and retrieve embedded knowledge chunks (the essence of our RAG system).
- Web scraping capabilities to pull data from specific websites when needed.
- Calls to Perplexity’s API via Sonar Pro for deep research on the web.
While this might sound like many moving parts, AI coding assistants made it far less intimidating. I described what I wanted in plain language, and the AI would generate boilerplate code, help me set up API endpoints, and even provide debugging tips. This approach shows how accessible AI-powered development can be for teams at any skill level—especially for those who got a head start with something like n8n.
Understanding RAG (Retrieval-Augmented Generation)
A major component of our application is RAG, or Retrieval-Augmented Generation. Think of RAG as giving your AI the ability to “look up” relevant information before generating a response. This is especially useful for businesses with large document repositories—like policies, meeting notes, contracts, onboarding scripts, or training manuals.
Here’s how our RAG system works in plain language:
- Document Processing: We feed our internal documents (or any content we deem valuable) into a process that creates “vector embeddings.” It breaks these documents into small chunks of text and converts each chunk into a vector representation that captures its meaning.
- Vector Storage: We store these vectors in a database (we’re using Supabase for this). This database lets us quickly search through all the documents by comparing vector similarities, not just keywords.
- Relevance Retrieval: When someone asks the AI a question, “What is the onboarding process for a new enterprise client?” the system searches through the vector database to find the most relevant chunks of text related to enterprise onboarding.
- Contextual Response: The AI model then uses those retrieved chunks to augment its response, ensuring it’s not just guessing based on general training, but rather referencing our specific, up-to-date internal knowledge.
This has been a game-changer for us. Instead of rummaging through multiple folders or wikis, our team can now ask the AI. Within seconds, they get an answer compiled from the exact internal sources that matter. Compared to custom GPT’s file limit, our RAG approach can scale with as many documents as we need—no more re-uploading whenever we start a new conversation.
The Tech Stack Explained
Even though we built this for internal use, the same tech stack can be applied to external, customer-facing applications or educational platforms. Here’s a closer look at the major pieces:
Next.js with TypeScript
Next.js is a popular React framework that offers server-side rendering, static site generation, and a simple way to build APIs without needing a separate backend. Using TypeScript adds type safety, making code easier to maintain and refactor—especially when you’re leaning heavily on AI-generated code. If you’ve played around with n8n’s visual approach, you’ll love how Next.js structures your application in a straightforward yet scalable way.
Vercel AI SDK
The Vercel AI SDK simplifies calling large language models (LLMs) like GPT-4. It handles streaming, formatting requests, and parsing responses. It lets you connect your user input to an AI model with minimal custom code. The real-time streaming effect—where the answer scrolls out word by word—creates a more engaging user experience that feels like a conversation rather than a static Q&A.
Shadcn UI Components
For the frontend, we incorporated Shadcn UI components. These are pre-built React components designed for accessibility, style, and ease of use. Whether it’s a chat window, a file uploader, or a dropdown menu, these components made our interface look polished without needing deep design expertise. This starkly contrasts the more bare-bones UI you might get from something like n8n, which is geared towards workflows rather than a sleek end-user experience.
Supabase (Vector Database + Auth)
Supabase acts as our database and authentication layer. We store user info, manage roles (like employee vs. mastermind student), and handle the vector embeddings for our RAG system. Because Supabase offers a Postgres-based solution with built-in vector support, it’s straightforward to query the database for the most semantically similar chunks when generating an answer. This approach is far more flexible than the “one-file-at-a-time” limitation we faced using custom GPT uploads.
Web Scrapers & Perplexity API (Sonar Pro)
Our tool can also call external “plugins” or “tools.” For instance, if you ask a question that requires the latest data from a niche website, the AI can invoke a custom web scraper. Or if you need a deeper dive into a complex topic, the AI can call the Perplexity API via Sonar Pro for research. This is what we call “tool calls,” giving the AI superpowers to look things up beyond our internal knowledge base. While n8n allowed us to do web scraping, the new app’s integrated tool-calling system is more efficient, keeps context, and seamlessly merges results into the conversation.
Cursor and Claude for Coding
While this isn’t part of the application itself, mentioning how I built it is crucial. Cursor and Claude functioned like coding buddies. I’d type instructions like, “Generate a Next.js API route for user authentication,” and the AI would provide a starter template. This approach drastically cut down development time and made the learning process smoother. If you’ve ever tried building complex workflows in n8n, imagine that same “drag-and-drop” ease applied to writing code.
Agent Selector: Taking Precision to the Next Level
One of the most remarkable features we added is an Agent Selector. When building with custom GPT, we encountered the issue of having all sorts of knowledge mixed in one AI session. We wanted a way to focus the AI on specific areas of expertise. So we created specialized “agents” with distinct roles, such as:
- Google Ads Agent: Only references our Google Ads documentation, best practices, and previous campaign data.
- Facebook Ads Agent: Focuses solely on Facebook marketing strategies, targeting guidelines, and compliance details.
- Quiz Agent: Concentrates on technical SEO audits, keyword research, and content optimization strategies.
- Copywriting Agent: Writes copy for email, websites, social media campaigns and can copy edit existing campaigns
When you switch to a given agent, the tool automatically pulls from the relevant embeddings for that subject. This way, you’re not risking “cross-contamination” from other knowledge areas, making the responses laser-focused and more accurate. In contrast, custom GPT tends to blend everything into one environment, forcing you to rely on carefully worded prompts or repeatedly re-upload files to maintain context. Our agent-based approach solves that elegantly.
How We Use the Tools Internally
1. Faster Onboarding
Of course, the biggest win is speeding up client onboarding. Our employees can ask the AI about processes, retrieve onboarding checklists, or generate personalized emails for new clients. Our knowledge base documents everything, so the AI’s responses are consistent and accurate. We no longer lose time searching for the right documents or rewriting the same explanations.
2. Training New Employees
New hires often ask a lot of questions about company policies, daily workflows, or best practices. Instead of reading through a massive wiki, they can jump straight into our AI tool. The RAG system references internal handbooks and training materials. This guided, interactive approach has halved the time spent on new-employee orientation.
3. Content Creation & Research
The tool can assist with research and outline generation for teams that produce educational content—whether for our mastermind students or internal newsletters. The AI can quickly gather data on a topic and produce an organized summary by leveraging the Perplexity API or web scraping functions. This is then cross-referenced with any internal materials we’ve embedded. Compared to the linear workflows we used to set up in n8n, this integrated approach allows for immediate iterative feedback.
4. Quick FAQs
Repetitive questions about company holidays, procedures for expense reimbursement, or meeting schedules used to clog our internal Slack channels. Employees can ask the AI: “When’s our next holiday break?” or “How do I submit a travel expense?” The system instantly pulls the relevant chunk from our knowledge base. No more repeated Slack messages or digging through old documents.
5. Mastermind Student Support
For the students in our mastermind program, we grant limited access to the tool so they can ask questions about the program’s content, upcoming modules, or recommended resources. The AI references our curated mastermind materials, making it easy for students to find what they need quickly. By separating roles and permissions, we maintain a secure environment while delivering high-value assistance.
Measuring Success: 30 Days Down to Less Than 7
Our onboarding process took around 30 days when we started—mainly because of back-and-forth communications, data gathering, and manual referencing. After integrating the AI tool, our internal team could instantly pull the proper documents, follow standardized but flexible scripts, and keep clients engaged without delays. The result? We typically onboard a new client in under a week now.
Why is this speedup so significant?
- Enhanced Client Confidence: Clients feel more supported because we respond to their queries quickly and accurately.
- Focused Employee Time: Our team can focus on strategic tasks, rather than hunting for information in multiple places.
- Scalable Processes: Onboarding used to be a bottleneck, but now we can handle multiple new clients in parallel without overwhelming the team.
Lessons Learned Along the Way
1. Don’t Underestimate the Importance of Data Preparation
AI is only as good as the data it can reference. We spent considerable time structuring our internal documents—removing duplicates, ensuring the text is up to date, and creating a clear taxonomy before generating vector embeddings. A messy knowledge base leads to messy AI answers.
2. Start Simple with Tool Calls
While it’s tempting to build a million “superpowers” for your AI right away—like advanced web scraping or API integrations—start with the basics. Make sure the fundamentals (like internal knowledge retrieval) work flawlessly, then add external tool calls selectively.
3. AI Assistants Don’t Replace Human Code Reviews
Cursor and Claude helped immensely, but they aren’t infallible. I still spent time reviewing, testing, and refactoring the generated code. Treat AI coding assistants as helpful partners, not final authorities.
4. User Experience Matters
We used Shadcn UI for a reason. Even with the most powerful AI backend, if your employees or students find the interface confusing, they won’t use it. Pay attention to accessibility, loading states, user feedback, and clarity. This is one area where we evolved beyond the purely functional UI n8n provides, aiming for a polished product that people enjoy using.
5. Cost Management
AI tools can get expensive fast, especially if your usage grows. We optimized by batching requests, caching responses, and closely monitoring how often we call external APIs. Being mindful of usage patterns can keep costs within budget, and ensures that the tool remains a strategic advantage rather than a financial drain.
Best Practices for Building Your AI Application
1. Identify Clear Use Cases
Before writing a single line of code (or prompting an AI to do it), define why you need AI. For us, it was speeding up onboarding. That clear objective guided all our decisions and prevented feature creep.
2. Choose the Right Model and SDK
We opted for GPT -4o, GPT-o1, and Perplexity Sonar-Pro (we’ll soon add Grok 3 when the API is available) via the Vercel AI SDK because we needed advanced reasoning capabilities. If your use case is simpler, you could use a smaller or cheaper model. The key is matching the model’s strengths to your business needs.
3. Iterate Quickly with AI Coding Help
If you’re new to coding, or just want to speed up development, AI coding assistants can help you prototype at lightning speed. Start small, see what works, and refine as you go. We did a lot of this in n8n before coding our own custom app.
4. Implement a Testing Strategy
Even though AI can produce good answers, you still need tests—unit tests, integration tests, and scenario-based tests—to catch issues. The same goes for verifying that your tool calls work as intended. Please don’t leave it up to chance.
5. Pay Attention to Data Privacy and Security
You might be embedding proprietary or sensitive documents into your vector database. Ensure you have proper access controls, encryption, and role-based permissions to safeguard this information.
6. Prepare for Scaling
If your application becomes popular internally or externally, you must handle more concurrent users. Next.js can scale easily on platforms like Vercel, but keep an eye on your AI API usage and vector database performance as traffic grows.
Expanding Beyond Internal Use
Although our application is primarily for internal processes and mastermind students, there’s immense potential to adapt the same approach for external-facing solutions. Imagine a customer support chatbot that references user manuals, billing policies, and FAQ documents, all stored as vector embeddings. Or an educational platform that can provide personalized tutoring based on a student’s curriculum.
We’re already brainstorming new features, like:
- Automatic Summarization of Meeting Transcripts: Quickly get a concise recap of essential points.
- Chat-Driven Scheduling: Where the AI integrates with our calendar system to set appointments.
- Automated Compliance Checks: The AI can flag discrepancies in real time for complex regulatory environments.
The sky’s the limit, especially as AI models continue to improve and new tools emerge. Our transition from n8n-based workflows to a fully custom-coded system shows how quickly you can move once you see what’s possible.
Conclusion: Why AI-Powered Apps Are the Future
Our journey from manual, 30-day onboarding processes to an AI-driven solution that achieves the same result in under a week is a testament to how transformative AI can be. The best part? You don’t have to be a coding genius to get started—AI coding assistants, accessible frameworks, and well-documented SDKs level the playing field.
By combining:
- Next.js and TypeScript for a modern, scalable web application,
- A robust vector database for retrieval-augmented generation,
- Tool calls like web scrapers and API integrations for real-time data fetching,
- And user-friendly UI components,
We’ve built an internal tool that doesn’t just chat—it gets real work done. Our employees and mastermind students now have a reliable assistant that taps into our entire knowledge base, performs deep web research, and provides actionable answers. This hybrid approach—part chat, part agent, part research assistant—represents the future of AI applications in the workplace.
If you’re reading this and feeling inspired, consider leaping. Whether you’re a fresh-faced coder (like I was) or a seasoned developer, you can harness AI to build tools that streamline workflows, improve collaboration, and deliver real ROI. AI is no longer just about “chatting.” It’s about creating intelligent systems that augment human capabilities. And as our experience shows, those systems can dramatically transform your business processes—even something as traditionally cumbersome as client onboarding.
We’re only at the beginning of our AI journey, and we’ve already seen massive efficiency gains. I can’t wait to see what others create with the same technologies. If you’re thinking about building your own AI application—whether for internal use or a broader audience—remember: define your goals clearly, pick the right tech stack, and let AI do the heavy lifting where it excels.
Welcome to the next generation of AI applications. It’s a world where processes that used to take weeks can now be done in days—or even minutes—and where anyone, beginner or not, can build sophisticated, scalable solutions with the right approach.
Thanks for reading! Feel free to reach out if you have any questions about implementing AI, vector embeddings, or how to integrate tool calls like web scraping or deep research APIs. Our journey was full of aha moments and learning experiences, and we’re happy to share what we’ve discovered along the way. Here’s to building the future of work with AI!
Humberto Garcia is the world’s leading photography business growth expert.
Founder of Photography to Profits and high-performance coach to multiple 6-figure photography businesses. Humberto coaches photographers from his special operations military experience and photography sales and marketing experience. After years of high performance in Marine Special Operations and building businesses, he knows what works.
