Contributing

Join the Marketplace

The Architech is open-source and community-driven. The marketplace thrives because developers like you contribute adapters, connectors, and features that solve real problems.

This is your guide to becoming a marketplace contributor.

Why Contribute?

For You

🎯 Showcase your expertise — Build your developer portfolio
🚀 Solve once, benefit forever — Automate solutions you use repeatedly
🌟 Gain recognition — Contributors are credited in the marketplace
📚 Learn best practices — Work with industrial-grade architecture

For the Community

🔧 Expand capabilities — More options for every project
🏗️ Build the supply chain — Create the future of software development
🤝 Share knowledge — Your solutions help thousands of developers
🌍 Drive innovation — Push the boundaries of code generation

Contribution Process Overview

1. Choose Your Role → 2. Set Up Development → 3. Build Your Module → 4. Test Thoroughly → 5. Submit Pull Request → 6. Review & Publish

Let's walk through each step.

Step 1: Choose Your Role

Decide what type of module you want to contribute. Review the three tiers:

Option A: Adapter (Raw Materials)

Choose if you want to:

Add support for a new technology
Provide an alternative to an existing adapter
Enable a foundation that others can build on

Examples:

New ORM (TypeORM, Sequelize)
New UI library (Ant Design, Chakra)
New service (Twilio, SendGrid)

👉 Read: Architecture Guide - Adapters

Option B: Connector (Technical Bridges)

Choose if you want to:

Connect two or more technologies
Generate Golden Core API wrappers
Provide framework-specific integrations

Examples:

prisma-remix — Prisma + Remix integration
supabase-nextjs — Supabase + Next.js integration
auth0-react — Auth0 + React integration

👉 Read: Architecture Guide - Connectors

Option C: Feature (Business Capabilities)

Choose if you want to:

Deliver complete user-facing functionality
Provide UI-agnostic business logic
Build production-ready features

Examples:

Blog system with multiple UI implementations
CRM dashboard with analytics
File upload manager with cloud storage

👉 Read: Architecture Guide - Features

Step 2: Set Up Development Environment

Prerequisites

Node.js 18+ and npm 8+
Git for version control
TypeScript knowledge
Understanding of The Architech architecture

Fork and Clone

# Fork the marketplace repository on GitHub
# Then clone your fork
git clone https://github.com/<your-username>/architech-marketplace.git
cd architech-marketplace
 
# Add upstream remote
git remote add upstream https://github.com/the-architech-xyz/marketplace.git
 
# Install dependencies
npm install
 
# Create a feature branch
git checkout -b feature/my-awesome-module

Development Setup

# Link the marketplace locally
npm link
 
# Create a test project
cd ..
mkdir test-project && cd test-project
architech init
 
# Link to your local marketplace
npm link @architech/marketplace

Now you can test your module as you build it.

Step 3: Build Your Module

Using the CLI Scaffolder

The Architech provides a scaffolding tool to generate the boilerplate:

# For an Adapter
architech create-module adapter <category>/<name>
# Example: architech create-module adapter database/typeorm
 
# For an Connector
architech create-module connector <name>
# Example: architech create-module connector typeorm-nextjs
 
# For a Feature Core
architech create-module feature-core <name>
# Example: architech create-module feature-core blog-system
 
# For a Feature UI
architech create-module feature-ui <name>
# Example: architech create-module feature-ui blog-system-shadcn

This generates the complete file structure with template files.

File Structure Created

marketplace/<modules>/<category>/<your-module>/
├── adapter.json / connector.json    # Metadata
├── blueprint.ts                       # Generation logic
├── templates/                         # Code templates
├── tests/                            # Test files
├── README.md                         # Documentation
└── CHANGELOG.md                      # Version history

Implement Your Module

Follow the guide for your module type:

Define metadata in adapter.json or connector.json
- Set capabilities (provides, requires)
- Define dependencies
- Add user prompts
Write blueprint logic in blueprint.ts
- Implement the generate() function
- Use the Blueprint API
- Follow architectural patterns
Create templates in templates/
- Use EJS templating syntax
- Ensure proper TypeScript typing
- Add helpful comments
Write documentation in README.md
- Explain what the module does
- List prerequisites
- Provide usage examples
- Document environment variables

Step 4: Test Thoroughly

Testing is non-negotiable. Your module must be reliable.

Unit Tests

Test your blueprint logic:

// tests/blueprint.test.ts
import { testAdapter } from '@architech/testing';
 
describe('MyAdapter', () => {
  it('should generate correct files', async () => {
    const result = await testAdapter('my-adapter', {
      answers: { option: 'value' }
    });
    
    expect(result.files).toContain('expected-file.ts');
    expect(result.dependencies).toHaveProperty('expected-package');
  });
  
  it('should handle edge cases', async () => {
    // Test error conditions
    // Test with different configurations
    // Test prerequisite validation
  });
});

Integration Tests

Test the generated code:

# Create test project
cd tests/integration
architech new test-app --minimal
 
# Install your module
cd test-app
architech add adapter my-adapter
 
# Run build
npm run build  # Must succeed
 
# Run type checking
npm run type-check  # Must pass
 
# Run linting
npm run lint  # Must pass
 
# Run tests
npm run test  # Must pass

Manual Testing

# Test in different scenarios
1. Fresh project (architech new)
2. Existing project (architech add)
3. With different prerequisites
4. With different frameworks
5. With different configurations

Test Checklist

Step 5: Submit Pull Request

Pre-Submission Checklist

Before submitting, ensure:

Code Quality:

Follows The Architech architectural patterns
Uses Golden Core APIs where applicable
Fully typed with TypeScript
No linter errors
Follows naming conventions

Testing:

All unit tests pass
Integration tests pass
Manual testing completed
Edge cases covered

Documentation:

Metadata:

Correct capabilities declared
Dependencies properly specified
Version follows semver
Author information included

Creating the PR

# Ensure you're on your feature branch
git checkout feature/my-awesome-module
 
# Commit your changes
git add .
git commit -m "feat(adapter): add TypeORM adapter
 
- Supports PostgreSQL, MySQL, and SQLite
- Generates type-safe entities
- Includes migration scripts
- Fully tested and documented"
 
# Push to your fork
git push origin feature/my-awesome-module
 
# Create PR on GitHub
# Use the PR template provided

PR Template

## Module Type
- [ ] Adapter
- [ ] Connector
- [ ] Feature
 
## Description
[Clear description of what your module does]
 
## Capabilities
Provides: `database`, `orm`, `typeorm`
Requires: [List prerequisites]
 
## Testing
- [ ] Unit tests added/updated
- [ ] Integration tests added/updated
- [ ] Manual testing completed
- [ ] Works with Next.js
- [ ] Works with Remix
- [ ] [Other scenarios]
 
## Documentation
- [ ] README.md complete
- [ ] Usage examples included
- [ ] Environment variables documented
 
## Breaking Changes
[List any breaking changes, or "None"]
 
## Related Issues
Closes #[issue number]

Step 6: Review & Publish

Review Process

Automated Checks — CI runs all tests and linting
Architectural Review — Maintainers verify adherence to patterns
Code Review — Quality, security, and best practices
Testing Review — Coverage and edge case handling
Documentation Review — Completeness and clarity

Addressing Feedback

Maintainers may request changes:

# Make requested changes
git add .
git commit -m "fix: address review feedback"
git push origin feature/my-awesome-module
 
# PR updates automatically

Publication

Once approved:

✅ PR merged to main
✅ Module added to marketplace
✅ Documentation published
✅ You're credited as contributor

Architectural Standards

All contributions must follow these standards:

1. Opinionated Core, Agnostic Edges

Adapters: Stay at the agnostic edges
Connectors: Enforce Golden Core APIs
Features: Use headless + UI pattern

2. Golden Core APIs

When generating data hooks:

✅ Use TanStack Query
✅ Follow useGetEntity, useCreateEntity pattern
✅ Include proper cache invalidation

When generating state:

✅ Use Zustand
✅ Follow store best practices

When generating forms:

✅ Use React Hook Form + Zod
✅ Type-safe validation

3. TypeScript First

All generated code must be TypeScript
Use strict mode
No any types
Leverage type inference

4. Capability System

Accurately declare provides capabilities
Correctly list requires prerequisites
Use standard capability naming

5. Template Quality

Use EJS syntax correctly
Add helpful comments
Follow coding standards
Ensure proper formatting

Community Guidelines

Code of Conduct

We enforce a strict code of conduct:

✅ Be respectful and inclusive
✅ Provide constructive feedback
✅ Collaborate in good faith
✅ Help others learn and grow
❌ No harassment or discrimination
❌ No spam or self-promotion
❌ No malicious code
❌ No plagiarism

Getting Help

Stuck? Ask for help:

Discord: The Architech Community (opens in a new tab)
GitHub Discussions: Technical questions
GitHub Issues: Bug reports and feature requests

Mentorship Program

New to The Architech? Request a mentor:

# In our Discord, use the command
/request-mentor
 
# A core contributor will guide you through your first contribution

Contributor Recognition

We celebrate our contributors:

Recognition Levels

🌱 First Contribution

Your first merged PR
Listed in CONTRIBUTORS.md
Contributor badge on Discord

🌿 Active Contributor

5+ merged PRs
Featured in monthly highlights
Early access to new features

🌳 Core Contributor

20+ merged PRs
Invited to core contributor team
Voting rights on major decisions
Listed on main website

🏆 Module Maintainer

Maintain 1+ official modules
Direct commit access to your modules
Highlighted in marketplace

Advanced: Creating Official Genomes

Genomes are complete project blueprints that combine multiple modules.

Genome Structure

// genomes/official/my-genome.ts
import { defineGenome } from '@architech/types';
 
export default defineGenome({
  name: 'my-awesome-genome',
  description: 'Complete setup for [use case]',
  version: '1.0.0',
  
  modules: [
    // Adapters
    { type: 'adapter', name: 'nextjs' },
    { type: 'adapter', name: 'drizzle' },
    { type: 'adapter', name: 'shadcn' },
    
    // Connectors
    { type: 'connector', name: 'drizzle-nextjs' },
    { type: 'connector', name: 'tanstack-query-nextjs' },
    
    // Features
    { type: 'feature', name: 'auth', ui: 'shadcn' },
    { type: 'feature', name: 'teams-dashboard', ui: 'shadcn' },
  ],
  
  prompts: [
    {
      name: 'projectName',
      type: 'text',
      message: 'Project name'
    }
  ],
  
  postInstall: `
    Your project is ready!
    
    Next steps:
    1. cd {{projectName}}
    2. npm install
    3. npm run dev
  `
});

Submitting Genomes

Official genomes require:

Comprehensive testing
Complete documentation
Proven use case
Community demand

FAQ

How long does review take?

Typically 3-7 days. Complex modules may take longer.

Can I update my module after publishing?

Yes! Submit a new PR with version bump in CHANGELOG.md.

What if my module breaks?

We'll work with you to fix it. Critical issues may require temporary removal.

Can I contribute proprietary tech?

Yes, if you have rights. Ensure licensing compatibility.

Do I need to support my module forever?

No, but we encourage maintenance. We can help find new maintainers.

Next Steps

Ready to contribute?

Join Discord — The Architech Community (opens in a new tab)
Review Architecture — Architecture Guide
Study Examples — Browse marketplace/ directory
Start Small — Pick an adapter to begin
Ask Questions — We're here to help

The marketplace grows with every contribution. Your module could help thousands of developers. Let's build the future together.

Quick Start (30 Minutes)V1 Overview