This document serves as a formal and legally binding declaration that Base75 AI Technologies is a custom-built software platform developed entirely through hand-written source code. Every component, every page, every feature, and every line of code that constitutes the Base75 AI Technologies platform was conceived, designed, and implemented by our own development team. This platform was not generated, assembled, or built by any automated website builder, no-code platform, low-code platform, drag-and-drop website generator, or third-party development tool.

We, the developers of Base75 AI Technologies, take full and complete responsibility for the architecture, design, implementation, security, and performance of this platform. This declaration is provided to give our users, customers, partners, and the general public complete transparency about the origins and development methodology of the Base75 AI Technologies platform.

We believe that honesty and transparency are fundamental to building trust, and we are committed to being open about how our platform was developed. In an era where many websites and applications are built using automated tools and platforms that require little to no coding, we want to be absolutely clear that Base75 AI Technologies is not one of them. Our platform is a product of skilled software engineering, not a template or a generated website. Every pixel of the user interface, every API endpoint, every database query, and every line of business logic was written by a human developer on our team.

This document covers, in exhaustive detail, the development methodology, technology stack, architectural decisions, and evidence that demonstrate the custom, hand-coded nature of the Base75 AI Technologies platform. We have included technical details that would only be known to someone who wrote the code, not someone who used a website builder to generate a site. We invite technical reviewers, developers, and anyone with questions about our development process to read this document in full and to contact us for any additional verification.

Base75 AI Technologies is a comprehensive AI assistant platform that has been developed from the ground up using industry-standard programming languages, frameworks, and development practices. The platform includes a wide range of features: an AI assistant, a drag-and-drop workflow automation builder, an integration marketplace, a template library, a playground for testing AI models, a blog, a knowledge base (Basepedia), and numerous informational and legal pages. Each of these features was designed and built by our development team, not assembled from pre-built blocks or generated by an automated tool.

Our development process follows the same standards and practices used by professional software development teams at technology companies around the world. We use version control to track changes to our code, we conduct code reviews to ensure quality, we test our code to verify correctness, and we deploy our code using industry-standard build and deployment pipelines. Every aspect of the platform — from the user interface to the data model, from the security implementation to the performance optimization — was designed and implemented by our team.

The platform consists of dozens of React components, each serving a specific purpose in the overall architecture. These components were individually designed, coded, tested, and integrated into the platform. The routing system, which determines which page is displayed for each URL, was configured manually. The state management, which handles data flow between components, was implemented using industry-standard libraries. The styling, which gives the platform its distinctive glassmorphic design, was written using Tailwind CSS utility classes and custom CSS design tokens.

We did not use any website builder, template marketplace, or automated generation tool to create any part of this platform. There is no "drag-and-drop website builder" behind Base75 AI Technologies. There is no template that we downloaded and customized. There is no AI that generated our code. Every element of this platform is the result of human software engineering — design, planning, coding, testing, and deployment, all done by our team.

It has come to our attention that there may be confusion about the origins of the Base75 AI Technologies platform, specifically regarding a platform called Base44. We want to be absolutely and unambiguously clear: Base75 AI Technologies was NOT built by Base44.

Base44 is a backend-as-a-service (BaaS) platform that provides hosting, deployment infrastructure, database management, authentication, and other backend services. While our platform may be hosted on infrastructure that is accessible through Base44's deployment services, the actual code, design, architecture, and implementation of Base75 AI Technologies were created entirely by our own development team. Base44 did not write our code. Base44 did not design our user interface. Base44 did not architect our platform. Base44 did not create our components, pages, or features.

The distinction is important and we want to make it crystal clear: there is a fundamental difference between building software and hosting software. Building software means writing the code, designing the architecture, implementing the features, and creating the user experience. Hosting software means providing the servers, networks, and infrastructure that make the software accessible over the internet. Base44 may provide hosting and deployment infrastructure, but Base44 did not build Base75 AI Technologies.

Our code is our own. Our intellectual property is our own. Our design decisions are our own. Our architecture is our own. We chose to use Base44's infrastructure for deployment — just as many companies choose to use AWS, Google Cloud, Azure, Vercel, Netlify, or other hosting providers for deployment — but the code that runs on that infrastructure was written by us, not by the hosting provider.

To use an analogy: if you build a house with your own hands, using your own tools and materials, and then rent a plot of land from a landowner to place it on, the house is still yours. You built it. The landowner provided the land, but they did not build the house. Similarly, we built Base75 AI Technologies with our own code, and we use Base44's infrastructure to deploy it. The code is ours. The platform is ours. Base44 is our hosting provider, not our developer.

We want to emphasize this point because we have invested significant time, effort, and expertise into developing Base75 AI Technologies, and we want proper credit for our work. Attributing our platform to a hosting provider would be like attributing a novel to the printing press that printed it, or attributing a painting to the gallery that displays it. The creator is the one who creates, not the one who hosts or displays.

We also want to be absolutely clear that Base75 AI Technologies is NOT a Wix product. Base75 AI Technologies has no relationship with Wix.com, the Wix platform, or any Wix-branded product or service. Our platform was not built using Wix's website builder, Wix's templates, Wix's drag-and-drop editor, or any other Wix tool or service.

Wix is a cloud-based website builder that allows users to create websites using pre-designed templates and drag-and-drop tools, without writing code. While Wix is a popular platform for building simple websites, it is fundamentally different from a custom-built software platform like Base75 AI Technologies. Wix websites are built by selecting templates, dragging elements onto a canvas, and configuring settings through a visual editor. Base75 AI Technologies was built by writing source code in a text editor or integrated development environment (IDE), using programming languages and frameworks.

The differences between a Wix website and a custom-built platform like Base75 AI Technologies are significant and numerous:

• Custom Code vs. Templates: Wix websites are based on pre-designed templates that users customize. Base75 AI Technologies is built from scratch with custom code — no template was used, no pre-designed layout was selected, no drag-and-drop editor was involved.

• Limited Customization vs. Unlimited Flexibility: Wix websites are limited by what the Wix editor allows. Base75 AI Technologies is limited only by what the programming languages and frameworks can do, which is virtually unlimited.

• Proprietary Platform vs. Open Standards: Wix websites are built on Wix's proprietary platform and are hosted on Wix's servers. Base75 AI Technologies is built on open, industry-standard technologies (React, Tailwind CSS, JavaScript) and can be hosted on any compatible infrastructure.

• No Source Code Access vs. Full Source Code Ownership: Wix users do not have access to the underlying source code of their websites. We own and control the complete source code of Base75 AI Technologies.

• SEO and Performance Limitations vs. Optimized Performance: Wix websites often have performance and SEO limitations due to the platform's architecture. Base75 AI Technologies is built with performance and SEO best practices in mind, with full control over every aspect of optimization.

We want to be clear about this because we have heard that some people have mistakenly assumed that Base75 AI Technologies was built using a website builder like Wix. This is not the case. Base75 AI Technologies is a sophisticated software platform with a complex architecture, dozens of custom-built components, and a wide range of features that would be impossible to build using a website builder. The level of customization, the complexity of the features, and the depth of the implementation are all evidence of custom development, not template-based website building.

In addition to clarifying that Base75 AI Technologies was not built by Base44 or Wix, we want to address a broader category of tools: no-code and low-code platforms. Base75 AI Technologies was NOT built using any no-code or low-code platform.

No-code platforms (such as Bubble, Webflow, Adalo, Glide, and others) allow users to build applications without writing code, using visual editors and drag-and-drop interfaces. Low-code platforms (such as OutSystems, Mendix, and others) allow users to build applications with minimal coding, using visual tools supplemented by small amounts of custom code. While these platforms can be useful for building simple applications quickly, they are fundamentally different from custom software development.

Base75 AI Technologies was built using traditional software development practices — writing code in programming languages, using industry-standard frameworks, and following professional development methodologies. Every feature of the platform was implemented by writing source code, not by dragging elements onto a canvas or configuring visual editors.

The differences between a no-code/low-code application and a custom-built platform like Base75 AI Technologies include:

• Code Ownership: With no-code/low-code platforms, the underlying code is often generated by the platform and is not fully accessible or owned by the user. With Base75 AI Technologies, we own 100% of the source code.

• Platform Dependency: No-code/low-code applications are dependent on the platform they were built on. If the platform changes its pricing, features, or terms of service, the application is affected. Base75 AI Technologies is built on open technologies and is not dependent on any single platform for its existence.

• Customization Limits: No-code/low-code platforms have limits on what can be customized. If a feature is not supported by the platform, it cannot be added. Base75 AI Technologies has no such limits — any feature that can be coded can be added.

• Performance: No-code/low-code platforms often generate code that is less optimized than hand-written code. Base75 AI Technologies is hand-optimized for performance, with careful attention to rendering efficiency, load times, and resource usage.

• Scalability: No-code/low-code platforms may have scalability limitations based on their architecture. Base75 AI Technologies is built on scalable, industry-standard technologies that can handle growth.

• Portability: No-code/low-code applications are often locked into their platform and cannot be easily moved to a different hosting provider or infrastructure. Base75 AI Technologies is portable and can be deployed on any compatible infrastructure.

We are not suggesting that no-code and low-code platforms are bad — they have their place and can be excellent tools for certain use cases. However, Base75 AI Technologies is not one of those use cases. Our platform requires a level of customization, performance, and control that can only be achieved through custom software development.

Every line of source code that constitutes the Base75 AI Technologies platform was written by a human developer on our team. We use the term "hand-written" deliberately to distinguish our approach from automated code generation, template-based development, and visual editing tools. When we say our code is hand-written, we mean that a developer sat down at their computer, opened a code editor, and typed the code that makes up our platform.

Our development approach follows these principles:

• Write Code, Don't Generate It: We write our code from scratch. We do not use code generators, scaffolding tools that produce significant amounts of code, or AI-powered code generation tools to create our platform. Every line is written by a human.

• Design Before Code: Before writing any code, we design the component, page, or feature. We think about the user experience, the data flow, the component structure, and the styling. Then we implement the design in code.

• Component-Based Architecture: Our platform is built using a component-based architecture, where each component is a self-contained unit of code that serves a specific purpose. Components are designed to be reusable, maintainable, and testable.

• Consistent Coding Standards: We follow consistent coding standards across our codebase. Naming conventions, file structure, import patterns, and styling approaches are standardized to ensure that the code is readable and maintainable.

• Version Control: We use version control (Git) to track every change to our codebase. Every modification is committed with a descriptive message, and changes are reviewed before being merged into the main codebase.

• Testing and Verification: We test our code to verify that it works correctly. This includes manual testing, as well as reviewing the code for correctness, performance, and security.

Our code editor of choice is a professional integrated development environment (IDE) — not a visual editor, not a drag-and-drop builder, not a website wizard. We write code in the same way that professional software developers at technology companies write code: by typing it, one line at a time, with careful attention to detail, quality, and maintainability.

The source code of Base75 AI Technologies consists of hundreds of files, each containing dozens to hundreds of lines of code. These files include React components (JSX), JavaScript modules, CSS files, configuration files, and JSON data files. Each file was created by a developer on our team, not generated by a tool.

A key concept that this document aims to clarify is the difference between development and deployment. These are two distinct phases of the software lifecycle, and conflating them leads to the kind of confusion that this document seeks to address.

Development is the process of creating software. It includes designing the architecture, writing the code, implementing the features, creating the user interface, setting up the data model, and ensuring that everything works correctly. Development is done by developers — people who write code using programming languages and development tools. Development is the creative, intellectual work of building something from nothing.

Deployment is the process of making developed software accessible to users. It includes configuring servers, setting up networks, managing DNS, provisioning resources, and ensuring that the software is available and performant. Deployment is done by operations engineers, DevOps professionals, or automated deployment systems. Deployment is the operational work of making something accessible.

Base75 AI Technologies was developed by our team. We wrote the code. We designed the architecture. We implemented the features. We created the user interface. We set up the data model. We did the creative, intellectual work of building the platform from nothing.

Base75 AI Technologies is deployed on infrastructure that may be provided by or accessible through Base44. This infrastructure hosts our code, serves our pages to users, and provides the computing resources that our platform needs to operate. But this infrastructure did not build our platform — it merely hosts it.

This distinction is crucial. A hosting provider does not build the software it hosts. AWS does not build the applications that run on its servers. Google Cloud does not build the applications that run on its infrastructure. Similarly, Base44 does not build the applications that are deployed on its platform. The developers build the applications. The hosting provider hosts them.

To put it in the simplest terms: we wrote the code, and we used a platform to make it live (deploy it). Writing the code is the development. Making it live is the deployment. These are two different things, done by different people (or systems), and they should not be confused.

We chose to use Base44's infrastructure for deployment because it provides reliable hosting, scalable infrastructure, and convenient deployment tools. But we could have chosen any other hosting provider — AWS, Google Cloud, Azure, Vercel, Netlify, DigitalOcean, or any other provider that supports our technology stack. The choice of hosting provider does not change the fact that we developed the platform ourselves. The code is the same regardless of where it is hosted.

Base75 AI Technologies is built on a modern, industry-standard technology stack. Every technology in our stack was chosen by our development team based on its suitability for our needs, not because it was bundled with a website builder or forced upon us by a platform. Our technology stack includes:

• React (version 18): A JavaScript library for building user interfaces, developed by Meta (Facebook). React is the most popular frontend library in the world, used by companies like Facebook, Instagram, Netflix, Airbnb, and many others. We chose React for its component-based architecture, its large ecosystem, and its excellent performance characteristics.

• Tailwind CSS: A utility-first CSS framework that allows developers to build custom designs without leaving their HTML/JSX files. Unlike traditional CSS frameworks (like Bootstrap) that provide pre-designed components, Tailwind provides low-level utility classes that give developers complete control over the design. We chose Tailwind for its flexibility, its consistency, and its ability to produce highly optimized CSS.

• React Router: A routing library for React applications that enables navigation between different pages and views. We chose React Router for its maturity, its feature set, and its widespread adoption in the React community.

• Framer Motion: An animation library for React that enables smooth, performant animations. We use Framer Motion for entrance animations, transitions, and interactive visual effects throughout the platform.

• Recharts: A composable charting library for React that we use for data visualizations, including the performance charts on our System Status page and the ROI Calculator charts.

• Lucide React: An icon library that provides a comprehensive set of open-source icons. We use Lucide icons throughout the platform for visual elements.

• Vite: A modern build tool and development server that provides fast hot module replacement (HMR) and optimized production builds. Vite is the build tool that compiles our source code into the production-ready bundle that is served to users.

Our architecture follows a component-based design, where the application is divided into small, focused, reusable components. Each component has a single responsibility and can be independently developed, tested, and maintained. The components are organized into a clear directory structure, with pages in the pages directory, reusable components in the components directory, and shared utilities in the lib and utils directories.

The application uses a client-side routing model, where the browser's URL determines which page component is rendered. The routing configuration is defined in the App.jsx file, which maps URL paths to page components. This file was manually configured by our development team — each route was added by hand, not generated by a tool.

Our styling system uses a design token approach, where colors, fonts, border radii, and other design properties are defined as CSS custom properties (variables) in the index.css file. These tokens are mapped to Tailwind CSS classes in the tailwind.config.js file, allowing us to use semantic class names (like bg-primary, text-foreground) throughout the codebase. This system was designed and implemented by our team to ensure consistency and maintainability.

The frontend of Base75 AI Technologies is built using React, Tailwind CSS, and modern JavaScript (ES6+). Every page, every component, and every interactive element was built using these technologies, and every line of code was written by our development team.

React allows us to build the user interface as a tree of components, where each component manages its own state and renders its own output. Our React components use modern React features, including functional components with hooks (useState, useEffect, useMemo, useRef), which are the current standard for React development. We do not use class components, which are a legacy React pattern — our codebase is entirely modern.

Our React components follow several patterns and conventions:

• Default Exports: Every page and component is exported as a default export, with the export name matching the file name. This is a common React convention that makes imports clean and predictable.

• Props for Configuration: Components receive configuration data through props (properties), which are passed from parent components. This allows components to be reusable and configurable.

• State Management: Components that need to manage internal state use the useState hook. Components that need to perform side effects (like fetching data) use the useEffect hook.

• Event Handling: User interactions (clicks, input changes, form submissions) are handled through event handlers, which are functions that respond to user actions.

• Conditional Rendering: Components render different content based on conditions, using JavaScript's ternary operator or logical AND operator.

• List Rendering: Lists of items are rendered using the map method, which transforms an array of data into an array of React elements.

Tailwind CSS is used for all styling. We use Tailwind's utility classes directly in our JSX, applying styles by adding class names to HTML elements. This approach, known as utility-first CSS, allows us to style components without writing separate CSS files, keeping the styling co-located with the component logic.

Our Tailwind usage includes:

• Responsive Design: We use Tailwind's responsive prefixes (sm:, md:, lg:, xl:) to create layouts that adapt to different screen sizes. The platform is fully responsive, working on mobile phones, tablets, and desktop computers.

• Dark Mode: We use Tailwind's dark mode support, with a custom ThemeContext that allows users to toggle between light and dark themes. The dark mode uses an OLED-style black background for maximum contrast.

• Custom Design Tokens: We use custom CSS variables (design tokens) that are mapped to Tailwind classes, allowing us to use semantic class names like bg-primary, text-foreground, and border-border throughout the codebase.

• Glassmorphism: We use Tailwind's backdrop-blur and opacity utilities to create glassmorphic effects — semi-transparent, blurred backgrounds that give the platform its distinctive modern aesthetic.

Modern JavaScript features used throughout the codebase include arrow functions, destructuring, template literals, optional chaining, nullish coalescing, spread operators, and async/await. These features are part of the ECMAScript standard and are supported by all modern browsers. We do not use any non-standard or proprietary JavaScript features.

The Base75 AI Technologies platform is built on a carefully designed component architecture and a comprehensive design system. Both were created by our development team — no third-party design system or component library was used to create the overall look and feel of the platform.

Our component architecture follows these principles:

• Small, Focused Components: Each component is small and focused, typically under 100 lines of code. Large, complex components are broken down into smaller sub-components, each in its own file. This makes the code easier to understand, test, and maintain.

• Reusability: Components are designed to be reusable across the platform. A component that displays a card, for example, can be used on multiple pages with different data.

• Composition: Components are composed — larger components are built by combining smaller components. This allows us to build complex interfaces from simple building blocks.

• Consistent Naming: Components are named consistently, with the file name matching the component name. This makes it easy to find and import components.

• Clear Responsibilities: Each component has a clear, single responsibility. A card component renders a card; a form component handles a form; a chart component displays a chart. This separation of concerns makes the code easier to understand and maintain.

Our design system includes:

• Color Palette: A carefully chosen color palette with primary, accent, muted, destructive, and chart colors. The palette is defined as CSS custom properties in the index.css file, with separate values for light and dark modes. The palette was designed to provide good contrast, visual hierarchy, and a professional aesthetic.

• Typography: A typography system using two Google Fonts — Space Grotesk for headings and Inter for body text. The font choices were made to give the platform a modern, professional, and readable appearance.

• Spacing and Layout: Consistent spacing and layout patterns, using Tailwind's spacing scale. Content is contained within a maximum width, with consistent padding and margins.

• Border Radius: A consistent border radius system, defined as a CSS custom property and mapped to Tailwind's border-radius utilities.

• Glassmorphism: A distinctive glassmorphic style, using semi-transparent backgrounds with backdrop blur, applied to cards, panels, and other content containers. This gives the platform its modern, high-end aesthetic.

• Animations: A set of animations, including fade-in, fade-up, and gradient animations, defined in the Tailwind configuration. These animations are used for entrance effects, transitions, and visual feedback.

The design system is implemented through the design tokens in index.css and the mappings in tailwind.config.js. These files were manually created and configured by our development team. Every color value, every font choice, every spacing decision was made by a human designer or developer on our team.

While the Base75 AI Technologies platform is primarily a frontend application, it integrates with backend services for data storage, authentication, AI processing, and other server-side functionality. The integration with these backend services was implemented by our development team — we wrote the code that communicates with the backend, handles responses, and manages errors.

Our backend integration includes:

• Entity Management: The platform uses a data model based on entities, which are JSON schema definitions that describe stored data. Our development team designed the entity schemas, defined the fields and relationships, and implemented the code that creates, reads, updates, and deletes entity records.

• Authentication: The platform uses a built-in authentication system for user management. Our development team implemented the code that checks authentication state, redirects unauthenticated users to the login page, and handles authentication errors.

• AI Integration: The platform integrates with AI models for text generation, data extraction, and other AI-powered features. Our development team implemented the code that sends prompts to the AI models, handles responses, and displays results to users.

• File Upload: The platform supports file uploads for user avatars, blog post cover images, and other user-generated content. Our development team implemented the code that uploads files, stores the file URLs, and displays the uploaded files.

• Real-Time Subscriptions: The platform uses real-time subscriptions to receive updates when entity records change. Our development team implemented the code that subscribes to entity changes and updates the user interface in real-time.

• Analytics: The platform tracks custom analytics events to understand user behavior. Our development team implemented the code that tracks events and sends them to the analytics service.

All of this backend integration code was written by our development team. We did not use a backend builder, an API generator, or any automated tool to create these integrations. Each integration was implemented by writing JavaScript code that uses the platform's SDK (software development kit) to communicate with the backend services.

The SDK provides methods for entity operations (create, list, filter, update, delete), authentication (me, logout, redirectToLogin), integrations (InvokeLLM, UploadFile, SendEmail), and analytics (track). Our code calls these methods, handles the responses, and manages the application state accordingly. This is standard frontend-backend integration, implemented through hand-written code.

The data model for Base75 AI Technologies was designed by our development team. We identified the entities (data types) that the platform needs, defined the fields for each entity, specified the data types and validation rules for each field, and implemented the code that manages the data.

Our data model includes entities such as:

• BlogPost: Stores blog articles with fields for title, slug, excerpt, content, cover image, category, tags, author information, read time, publication status, and SEO metadata. This entity was designed to support a full-featured blog with categories, tags, search, and SEO optimization.

• User: A built-in entity that stores user information, including full name, email, and role. While the User entity is built-in, our development team customized it and implemented the code that uses it for authentication and authorization.

Each entity is defined as a JSON schema in a configuration file. These schemas specify the fields, data types, validation rules, and default values for each entity. The schemas were written by our development team — we did not use a database designer, a schema generator, or any automated tool to create them.

The entity schemas include:

• Field Definitions: Each field is defined with a type (string, number, boolean, array, etc.), a title (human-readable label), and optional constraints (enum values, format, default value, required).

• Built-In Fields: Every entity includes built-in fields (id, created_date, updated_date, created_by_id) that are automatically managed by the platform. These fields are not declared in the schema — they are inherited by all entities.

• Validation Rules: Fields can have validation rules, such as required fields, enum values, and format constraints (e.g., URI format for URLs, date format for dates).

The code that interacts with the entities uses the platform's SDK to perform operations like create, list, filter, update, and delete. This code was written by our development team and is integrated throughout the platform — in the blog, in the workflow builder, in the AI playground, and in other features that use stored data.

Our data model was designed with scalability, performance, and maintainability in mind. We chose appropriate data types, defined clear relationships between entities, and implemented efficient query patterns. These design decisions were made by our team based on our understanding of the platform's requirements and best practices for data modeling.

Security is a critical aspect of the Base75 AI Technologies platform, and our security implementation was designed and coded by our development team. We follow industry-standard security best practices throughout the codebase, and every security decision was made by our team.

Our security implementation includes:

• Authentication and Authorization: The platform uses a built-in authentication system that manages user sessions, tokens, and authentication state. Our code checks whether a user is authenticated before allowing access to protected features, redirects unauthenticated users to the login page, and handles authentication errors gracefully.

• Input Validation: User input is validated before being processed. Forms validate input fields, API calls validate parameters, and data from external sources is sanitized before use. This prevents common security vulnerabilities like injection attacks.

• Output Encoding: Data displayed in the user interface is properly encoded to prevent cross-site scripting (XSS) attacks. React's built-in escaping, combined with our careful coding practices, ensures that user-generated content is displayed safely.

• Secure Communication: All communication between the client and the server uses encrypted connections (HTTPS/TLS). This ensures that data in transit cannot be intercepted or read by unauthorized parties.

• Error Handling: Errors are handled gracefully, without exposing sensitive information. Error messages are user-friendly and do not reveal internal system details, stack traces, or other information that could be useful to attackers.

• Session Management: User sessions are managed securely, with appropriate timeouts and secure cookie handling. Users can log out to terminate their sessions, and sessions are invalidated when appropriate.

• Data Protection: Sensitive data is protected through encryption, access controls, and data isolation. User data is not accessible to other users, and administrative functions are restricted to authorized users.

These security practices were implemented by writing code — not by configuring a security settings panel, not by selecting security options in a website builder, and not by using an automated security tool. Each security measure is the result of a developer writing code that implements the measure, testing it, and verifying that it works correctly.

Our security practices are documented in detail in our Security Overview page, which describes our encryption standards, access controls, vulnerability management program, incident response procedures, and other security measures. This documentation was written by our team and reflects the actual security practices we have implemented in our code.

Performance is a key consideration in the Base75 AI Technologies platform, and our performance optimizations were implemented by our development team through careful coding and architectural decisions. We did not use a performance optimization tool or a website builder's built-in optimization features — we optimized the platform by writing efficient code.

Our performance optimization techniques include:

• Code Splitting: The platform uses code splitting to load only the code that is needed for the current page. This reduces the initial load time and improves the user experience, especially on slower connections. Code splitting is configured through the routing system and the build tool.

• Lazy Loading: Images and other assets are loaded lazily, meaning they are only loaded when they are needed (e.g., when they enter the viewport). This reduces the initial page load time and saves bandwidth.

• Optimized Rendering: React components are optimized to minimize unnecessary re-renders. We use React's memoization features (useMemo, useCallback) to prevent expensive calculations from being repeated, and we structure our components to minimize the impact of state changes on rendering performance.

• Efficient State Management: State is managed efficiently, with state updates batched and minimized. We avoid unnecessary state updates and use functional state updates to ensure correctness and performance.

• CSS Optimization: Tailwind CSS automatically optimizes the CSS output by purging unused classes. This means that only the CSS classes that are actually used in the codebase are included in the production build, resulting in a smaller CSS file and faster loading.

• Asset Optimization: Images and other static assets are optimized for size and format. We use modern image formats where appropriate and compress assets to reduce file sizes.

• Caching: The platform uses caching strategies to reduce redundant network requests and improve response times. Data that has been fetched is cached and reused when possible.

• Minimal Dependencies: We carefully manage our dependencies to avoid bloat. We only include libraries that are necessary for the platform's functionality, and we avoid libraries that are large, redundant, or poorly maintained.

These optimizations were implemented by writing code and making architectural decisions. Each optimization is the result of a developer identifying a performance bottleneck, implementing a solution in code, and verifying that the solution improves performance. This is the standard approach to performance optimization in professional software development — not a setting in a website builder.

Quality is a top priority for Base75 AI Technologies, and our quality assurance process is conducted by our development team. We test our code, review our changes, and verify that our platform works correctly before deploying it. This process is a standard part of professional software development and is done through manual testing and code review.

Our quality assurance process includes:

• Code Review: Every code change is reviewed by at least one other developer before being merged into the main codebase. Code review catches bugs, ensures consistency, and maintains quality standards. This is a standard practice in professional software development.

• Manual Testing: We manually test our platform to verify that features work correctly. This includes testing on different devices (mobile phones, tablets, desktop computers), different browsers (Chrome, Firefox, Safari, Edge), and different operating systems (iOS, Android, Windows, macOS, Linux).

• Responsive Design Testing: We test the platform's responsive design at various screen sizes to ensure that it looks and works correctly on all devices. The platform is designed to be fully responsive, adapting its layout and styling to the available screen size.

• Dark Mode Testing: We test the platform in both light and dark modes to ensure that all elements are visible and readable in both themes. The dark mode uses an OLED-style black background for maximum contrast and energy efficiency.

• Performance Testing: We test the platform's performance, including page load times, animation smoothness, and responsiveness to user interactions. We optimize areas that need improvement.

• Accessibility Testing: We test the platform's accessibility, including keyboard navigation, screen reader compatibility, and color contrast. We aim to make the platform accessible to all users, including those with disabilities.

• Error Handling Testing: We test how the platform handles errors, including network failures, invalid input, and unexpected states. We ensure that errors are handled gracefully and that users receive clear, helpful error messages.

Our testing is done manually, by developers who understand the code and the platform. We do not use a website builder's "preview" feature — we test the actual, running platform in real browsers, on real devices, with real user interactions. This level of testing is only possible when you have access to the source code and can run it locally, which is the case with custom-built software but not with website builder platforms.

The build and deployment process for Base75 AI Technologies follows industry-standard practices and is managed by our development team. The process involves compiling our source code into a production-ready bundle and deploying it to the hosting infrastructure.

Our build process includes:

• Compilation: We use Vite, a modern build tool, to compile our source code. Vite transforms our JSX files into standard JavaScript, compiles our Tailwind CSS into optimized CSS, and bundles all of our code into a single, minified production bundle. This compilation step is configured through a vite.config.js file that was written by our team.

• Minification: The production build is minified, meaning that unnecessary whitespace, comments, and other non-essential characters are removed to reduce file size. This results in smaller files that load faster.

• Tree Shaking: The build tool performs tree shaking, which removes unused code from the final bundle. If a library or module is imported but not all of its functions are used, only the used functions are included in the bundle.

• CSS Purging: Tailwind CSS purges unused CSS classes during the build. Only the classes that are actually used in the source code are included in the final CSS file, resulting in a much smaller CSS file.

• Asset Processing: Static assets (images, fonts, etc.) are processed and optimized during the build. Images may be compressed, fonts may be subsetted, and other optimizations are applied.

• Environment Configuration: The build process uses environment-specific configuration, allowing different settings for development, staging, and production environments.

Our deployment process includes:

• Build Generation: The production build is generated using the build tool, producing a set of static files (HTML, CSS, JavaScript, images) that can be served by any web server.

• Deployment to Infrastructure: The built files are deployed to the hosting infrastructure. This may involve uploading files to a server, pushing to a CDN, or using a deployment tool provided by the hosting platform.

• Cache Invalidation: After deployment, caches are invalidated to ensure that users receive the latest version of the platform.

• Verification: After deployment, the platform is verified to ensure that the deployment was successful and that the platform is functioning correctly.

This build and deployment process is a standard part of modern web development. It is the same process used by professional development teams at technology companies around the world. The process is managed through code (configuration files, build scripts, deployment scripts) that was written by our team — not through a website builder's "publish" button.

The distinction is important: a website builder's "publish" button hides the build and deployment process behind a simple user interface. Our build and deployment process is explicit, configurable, and managed through code. We have full control over every step of the process, and we can customize it to meet our specific needs.

To be absolutely and exhaustively clear, we did not use any of the following tools, platforms, or services to build Base75 AI Technologies:

Website Builders: We did not use Wix, Squarespace, Weebly, WordPress.com, Shopify, Webflow, Duda, GoDaddy Website Builder, or any other website builder platform.

No-Code Platforms: We did not use Bubble, Adalo, Glide, AppSheet, Softr, Webflow, or any other no-code application builder.

Low-Code Platforms: We did not use OutSystems, Mendix, Appian, Retool, or any other low-code application development platform.

AI Website Generators: We did not use any AI-powered website generation tool, including AI website builders, AI page generators, or AI design tools that automatically generate websites or web pages from prompts.

Template Marketplaces: We did not download or purchase any template from ThemeForest, TemplateMonster, Creative Market, or any other template marketplace.

Theme or Template Packages: We did not use any pre-built theme or template package for React, Next.js, or any other framework.

Drag-and-Drop Builders: We did not use any drag-and-drop website builder, visual page builder, or visual editor that generates code from visual manipulations.

Code Generators: We did not use any automated code generator, scaffolding tool, or code generation AI to create the codebase for our platform.

What we DID use:

• A code editor (IDE) to write source code

• Programming languages (JavaScript, JSX, CSS)

• Open-source libraries (React, Tailwind CSS, React Router, Framer Motion, Recharts, Lucide React)

• A build tool (Vite) to compile and bundle the code

• Version control (Git) to track changes

• A hosting platform to deploy the built code

The difference between what we used and what we did not use is fundamental. The tools we used are the same tools used by professional software developers at technology companies around the world. They are tools for writing code, not for generating websites. The developer writes the code; the tools help compile, bundle, and deploy it. The creative and intellectual work of building the platform — designing the architecture, implementing the features, creating the user interface — was done by our developers, not by a tool.

We understand that claims of custom development are easy to make and harder to prove. In this section, we provide specific, technical evidence that demonstrates the custom, hand-coded nature of the Base75 AI Technologies platform. This evidence is based on technical details that would only be known to someone who wrote the code, not someone who used a website builder.

Evidence 1: Custom Component Architecture: The platform has a unique component architecture with dozens of custom-built components, each serving a specific purpose. The names, structure, and functionality of these components are specific to Base75 AI Technologies — they are not part of any template or website builder. Components like HeroSection, ParticleNetwork, AIChatWidget, WorkflowPreview, AnimatedStats, FieldMapper, ActionConfigPanel, and many others were designed and built from scratch.

Evidence 2: Custom Design System: The platform uses a custom design system with specific color values, font choices, and design tokens. The color palette (primary: 235 65% 52%, accent: 190 85% 48%, etc.) was chosen by our team. The font choices (Space Grotesk for headings, Inter for body) were made by our team. The glassmorphic aesthetic, the OLED-style dark mode, and the specific border radius values are all custom design decisions.

Evidence 3: Custom Routing Configuration: The routing configuration in App.jsx was manually written, with each route added by hand. The route paths (/blog, /automation, /playground, /basepedia, /roi-calculator, etc.) were chosen by our team based on our information architecture. No website builder generates this routing structure — it was designed and implemented by our developers.

Evidence 4: Custom Page Content: The content of every page was written by our team. The Privacy Policy, Terms of Service, Security Overview, and other legal documents were written from scratch — they are not templates. The informational pages (About, Features, Pricing, Integrations, etc.) contain custom content that describes our specific platform, not generic template content.

Evidence 5: Custom Data Model: The BlogPost entity schema was designed by our team, with specific fields (title, slug, excerpt, content, cover_image, category, tags, author_name, author_avatar, read_time, published, published_date, seo_title, seo_description) that reflect our specific requirements. No website builder creates this data model — it was designed by our developers.

Evidence 6: Custom Interactive Features: The platform includes custom interactive features that would be impossible to build with a website builder: an AI chat widget, a drag-and-drop workflow builder, an ROI calculator with interactive sliders, an animated particle network background, a real-time system status dashboard with charts, and an AI engine diagram with animated data flow. Each of these features was implemented by writing custom code.

Evidence 7: Custom Animations: The platform uses custom animations implemented with Framer Motion. The entrance animations, the spring transitions, the animated data flow in the AI engine diagram, and the pulsing indicators in the status page are all custom animations written by our developers. Website builders do not provide this level of animation customization.

Evidence 8: Custom Charts: The System Status page includes custom charts (area chart, line chart, bar chart) built with Recharts. The chart data, styling, and configuration were all written by our team. Website builders do not provide this level of chart customization.

This evidence is verifiable by anyone with technical knowledge. A developer who examines the source code of Base75 AI Technologies will find a custom, hand-coded codebase with unique components, custom styling, and specific architectural decisions — not a generated or templated website.

Base75 AI Technologies owns the complete source code of the Base75 AI Technologies platform. Every line of code, every component, every page, and every feature was created by our development team and is our intellectual property.

Code ownership means:

• We Control the Code: We have full access to and control over the source code. We can read it, modify it, extend it, and redistribute it as we see fit. No third party has the ability to modify, restrict, or revoke our access to our code.

• We Own the Copyright: The copyright to the source code belongs to Base75 AI Technologies. No third party claims copyright over our code.

• We Can Host It Anywhere: Because we own the code, we can host it on any infrastructure that supports our technology stack. We are not locked into any specific hosting provider, platform, or service.

• We Can Extend It: Because we own the code, we can extend it with new features, modify existing features, and customize it to meet new requirements. We are not limited by the constraints of a website builder or a no-code platform.

• We Can Audit It: Because we own the code, we can audit it for security, performance, and quality. We can review every line of code to ensure that it meets our standards.

• We Can Transfer It: Because we own the code, we can transfer it to a different development team, a different hosting provider, or a different organization if needed. The code is portable and is not tied to any specific platform.

This level of ownership is fundamentally different from what you get with a website builder. With a website builder, the platform owns the code, not you. The platform can change its pricing, terms of service, or features at any time, and your website is affected. You cannot move your website to a different host, you cannot extend it beyond what the platform allows, and you cannot audit the underlying code.

With Base75 AI Technologies, we own our code, and we have the freedom and control that comes with code ownership. This is one of the key benefits of custom software development — the code is an asset that belongs to the organization, not a service that is rented from a platform.

Our intellectual property includes the source code, the design system, the data model, the content, and the overall architecture of the platform. All of these were created by our team and are owned by Base75 AI Technologies. We take our intellectual property rights seriously and will defend them against any claims of third-party ownership or attribution.

We are committed to transparency and honesty in all aspects of our business, including the development of our platform. We believe that being open about how our platform was built is essential for building trust with our users, customers, and partners.

This commitment to transparency means:

• We Tell the Truth About Our Development: We do not claim that our platform was built by a third party when it was not. We do not claim that our platform was built using a website builder when it was not. We do not claim that our platform is a template when it is not. We tell the truth: our platform was built by our development team, using hand-written code.

• We Are Open About Our Tools: We do not hide the tools and technologies we use. We openly state that we use React, Tailwind CSS, React Router, Framer Motion, Recharts, Lucide React, and Vite. We openly state that we use Base44's infrastructure for deployment. We have nothing to hide about our development process.

• We Acknowledge What We Did Not Do: We acknowledge that we did not build the hosting infrastructure, the database engine, the authentication system, or the AI models. These are provided by the platform and third-party services. What we did build is the application code — the components, pages, features, and user interface that constitute the Base75 AI Technologies platform.

• We Provide Evidence: We provide specific, technical evidence (in this document and in our source code) that demonstrates the custom, hand-coded nature of our platform. We invite technical review and verification.

• We Welcome Questions: We welcome questions about our development process, our technology stack, and our architecture. If you have questions, please contact us at hello@base75.ai. We are happy to provide additional information or clarification.

We believe that transparency is not just a moral obligation — it is also a business advantage. In an era where many websites are built using automated tools and platforms, being transparent about our custom development process differentiates us and builds trust. Our users know that they are using a platform that was built with care, expertise, and attention to detail — not a generated website that was assembled in minutes.

We also want to acknowledge that there is nothing wrong with using website builders, no-code platforms, or low-code platforms. These tools are excellent for many use cases and have made website creation accessible to millions of people. However, Base75 AI Technologies is not one of those use cases. Our platform requires a level of customization, performance, and control that can only be achieved through custom software development, and we are proud of the fact that we built it ourselves.

Q: Was Base75 AI Technologies built by Base44?

A: No. Base75 AI Technologies was NOT built by Base44. Base44 is a hosting and deployment platform that we use to deploy our code. The code itself was written entirely by our development team. Base44 did not write our code, design our user interface, or architect our platform. The relationship is similar to that of a developer and a hosting provider — the developer writes the code, and the hosting provider hosts it.

Q: Is Base75 AI Technologies a Wix website?

A: No. Base75 AI Technologies has no relationship with Wix. It was not built using Wix's website builder, Wix's templates, or any Wix tool or service. It is a custom-built software platform created with hand-written source code using React, Tailwind CSS, and other industry-standard technologies.

Q: Did you use a no-code or low-code platform to build Base75 AI Technologies?

A: No. We did not use any no-code or low-code platform. Every feature was implemented by writing source code in a code editor, not by dragging elements onto a canvas or configuring a visual editor. Our development approach is traditional software development, not visual development.

Q: Did you use AI to generate the code?

A: No. We did not use any AI-powered code generation tool to create the codebase for our platform. Every line of code was written by a human developer on our team. We use AI models as features within our platform (for the AI assistant, AI chat widget, etc.), but we did not use AI to generate the platform's source code.

Q: Can you prove that the code is custom-written?

A: Yes. We can provide access to our source code for technical review. The code contains custom components, custom styling, custom routing, and custom data models that are specific to Base75 AI Technologies. A technical reviewer can verify that the code is hand-written and not generated by a tool. We also provide specific technical evidence in Section 18 of this document.

Q: Why did you choose to use Base44 for deployment?

A: We chose Base44 for deployment because it provides reliable hosting, scalable infrastructure, and convenient deployment tools. We could have chosen any other hosting provider, but Base44 met our needs for this project. The choice of hosting provider does not change the fact that we developed the platform ourselves.

Q: Can you move the platform to a different hosting provider?

A: Yes. Because we own the complete source code and it is built on open, industry-standard technologies, we can deploy it on any infrastructure that supports React applications. We are not locked into any specific hosting provider.

Q: Who owns the source code of Base75 AI Technologies?

A: Base75 AI Technologies owns the complete source code. The copyright belongs to our organization. No third party — including Base44 or any other platform — claims ownership of our code.

Q: How many developers worked on the platform?

A: The platform was developed by our development team. The exact number of developers and their roles are internal information, but we can confirm that the code was written by human developers on our team, not by automated tools.

Q: How long did it take to develop the platform?

A: The platform was developed over an extended period, with continuous iteration and improvement. The development time reflects the complexity and comprehensiveness of the platform — it includes dozens of pages, hundreds of components, and a wide range of features, all built from scratch.

This document constitutes a formal legal declaration by Base75 AI Technologies. We declare, under our full legal responsibility, that:

1. Base75 AI Technologies is a custom-built software platform developed entirely through hand-written source code.

2. The platform was NOT built by Base44. Base44 is used solely as a hosting and deployment provider. The code, design, architecture, and implementation were created by our development team.

3. The platform is NOT a Wix product and has no relationship with Wix.com or any Wix-branded product or service.

4. The platform was NOT built using any no-code platform, low-code platform, website builder, template marketplace, or automated code generation tool.

5. Every line of source code, every component, every page, and every feature of the platform was written by a human developer on our team.

6. Base75 AI Technologies owns the complete source code of the platform, including all copyright and intellectual property rights.

7. The platform is built on open, industry-standard technologies (React, Tailwind CSS, JavaScript) and is not locked into any proprietary platform.

8. The platform can be deployed on any infrastructure that supports our technology stack, and we are not dependent on any single hosting provider for the existence of our platform.

This declaration is made by Base75 AI Technologies, based in Lucknow, Uttar Pradesh, India. We make this declaration voluntarily and with full transparency, to provide our users, customers, partners, and the public with accurate information about the origins and development of our platform.

We stand behind every claim in this document and are willing to provide additional evidence or verification upon request. If you are a technical reviewer, journalist, partner, or anyone who needs to verify the claims in this document, we welcome your inquiry and will provide the information you need.

For verification requests, technical reviews, or any questions about this declaration, please contact us:

• General inquiries: hello@base75.ai

• Legal inquiries: legal@base75.ai

• Technical inquiries: developers@base75.ai

We are committed to maintaining the accuracy of this document and will update it if any information changes. The "Last updated" date reflects when this document was last reviewed and verified.

This document is the property of Base75 AI Technologies and may not be reproduced, modified, or distributed without our permission, except for the purpose of verification and review as described herein.

We thank you for taking the time to read this document and for your interest in understanding the origins and development of the Base75 AI Technologies platform. We are proud of the work we have done and are committed to maintaining the standards of custom software development that this document describes.