M
MediaSoftPro
Contact Request Demo →
Home/Technology Stacks
⚡Same Architecture · Full Feature Parity · Your Language of Choice

One Product.
Six Stacks.
Zero Compromise.

Every MediaSoftPro product ships in six technology stacks with a rigorous 7-layer clean architecture. Pick the language your team already knows — the features, AI integration, and architecture patterns are identical in every stack.

Request Demo Explore Stacks ↓
.NET 10 / C# 14+ Angular 21 Axum / RustComing Q4 2026 NestJS / TypeScript+ Next.js 15 Laravel / PHP 8.3+ Vue 3 + Inertia Golang / Gin+ Next.js 15 Python / Django 5+ DRF + Celery
🏗️
Same Architecture
7-layer clean arch across all stacks
🤖
Same AI Features
Claude AI integration in every stack
📦
Same Modules
Full module library, stack-idiomatic code
🔀
Same Domain Logic
DDD + CQRS consistent everywhere
🛡️
Same Security
JWT, OAuth2, RBAC, 2FA in all stacks
ASP.NET Stack — Flagship

.NET 10 / C# 14
+ Angular 21

Our original and most mature stack — evolved over 17+ years from ASP.NET WebForms to .NET 10 Minimal APIs. Features ship here first. The deepest documentation, reference implementation for all other stacks, and the team's deepest domain expertise.

⚡
Minimal API + SignalR Real-TimeLean Minimal APIs for high-throughput endpoints alongside SignalR for WebSocket-based live notifications, real-time dashboards, order tracking, and collaborative features.
🗄️
EF Core 10 + Dapper HybridEF Core 10 with compiled queries for rapid CRUD. Dapper for performance-critical raw SQL paths. Both used strategically within the same repo without conflict.
🖥️
Angular 21 + Next.js 15 FrontendAngular 21 for complex merchant dashboards and admin SPAs. Next.js 15 with App Router + RSC for SEO-critical public-facing pages. Both frontends shipped together.
⏰
Hangfire for Background ProcessingPersistent background job queuing for AI processing tasks, scheduled reports, email delivery, search indexing, and nightly data maintenance — with a built-in dashboard.
.NET 10 C# 14 MediatR 12 EF Core 10 FluentValidation Hangfire SignalR Angular 21 xUnit · Moq SQL Server / PG
ListingController.cs
// .NET 10 — Clean Architecture

[ApiController]
public class ListingController(ISender mediator)
: ControllerBase
{
// CQRS via MediatR
[HttpGet("{id:guid}")]
public async Task<IActionResult> Get(Guid id)
=> (await mediator.Send(new GetListingQuery(id)))
.Match(Ok, Problem);

// AI valuation endpoint
[HttpPost("ai/value")]
public async Task<IActionResult>
Valuate([FromBody] ValuationRequest req)
=> (await mediator.Send(new GetAIValuationCommand(req)))
.Match(Ok, Problem);

// Real-time search via SignalR
[HttpGet("search/nl")]
public async IAsyncEnumerable<ListingDto>
SearchNL(string query)
{
await foreach (var r in mediator
.CreateStream(new NLSearchQuery(query)))
yield return r;
}
}
Best for
✓Teams with existing .NET / C# expertise
✓Enterprise clients requiring Microsoft stack
✓Complex real-time feature requirements
✓Deepest documentation & longest track record
listing.service.ts
// NestJS — TypeScript DI + CQRS

@Injectable()
export class ListingService {
constructor(
private readonly repo: ListingRepository,
private readonly claude: ClaudeService,
private readonly queue: Queue,
) {}

async create(dto: CreateListingDto) {
// AI description via Claude
const desc = await this.claude
.writeDescription(dto);
const listing = await this.repo
.create({ ...dto, desc });
// BullMQ: async search index
await this.queue.add('index', { id: listing.id });
return listing;
}

// NL search → Elasticsearch
async searchNL(query: string) {
const parsed = await this.claude
.parseSearch(query);
return this.repo.elasticSearch(parsed);
}
}
NestJS 10 TypeScript 5 Prisma ORM BullMQ Next.js 15 Jest
TypeScript Stack

NestJS / Next.js
TypeScript End-to-End

The TypeScript-first stack for teams who want a single language across the full stack. NestJS brings Angular-style module architecture to the backend with decorator-based DI, guards, and interceptors. Next.js 15 powers SEO-optimised frontends with React Server Components.

🟢
NestJS Module ArchitectureDecorator-based DI, guards, interceptors, pipes, and microservice-ready module system. Familiar to Angular developers, perfect for large teams splitting into feature modules.
🗃️
Prisma ORM — Fully Type-SafeAuto-generated TypeScript types from your database schema. Zero runtime type errors between DB and API layer. Schema migrations, query builder, and relation management all type-checked at compile time.
⚡
BullMQ for AI ProcessingRedis-backed job queues run Claude AI tasks asynchronously — description generation, recommendation rebuilds, demand forecasting — without blocking request handling.
Best for
✓Full-stack TypeScript / JavaScript teams
✓Teams coming from Angular or Node.js backgrounds
✓Projects needing maximum type safety across layers
PHP Stack

Laravel 11 / PHP 8.3
+ Vue 3 + Inertia

The pragmatic PHP stack for teams with existing Laravel expertise. Eloquent ORM, Laravel Cashier for subscription billing, Horizon for queue monitoring, and Vue 3 with Inertia for a full SPA experience without a separate API layer.

🔴
Eloquent ORM + Geographic ScopesRich Eloquent model scopes for domain logic and location-based queries. Laravel Scout wraps Elasticsearch search — install one package and the search layer works out of the box.
💳
Laravel Cashier for SubscriptionsFirst-class Stripe subscription billing — subscription lifecycle, trials, cancellation, invoice generation, and Stripe webhook handling all handled natively by Cashier.
🏗️
Inertia.js + Vue 3 — SPA Without an APIFull SPA experience via Inertia — server-side routing with client-side rendering. No separate REST API layer needed for the frontend. Vue 3 Composition API with Pinia state management.
Laravel 11 PHP 8.3 Eloquent ORM Inertia.js Vue 3 Laravel Cashier Laravel Horizon Laravel Scout Pest / PHPUnit
ListingService.php
// Laravel — Eloquent + Claude AI

class ListingService
{
public function __construct(
private ClaudeService $claude,
private SearchService $search,
) {}

public function create(array $data): Listing
{
// AI description generation
$desc = $this->claude->writeDescription($data);
$listing = Listing::create([
...$data,
'description' => $desc,
]);
// Queue search indexing
IndexListingJob::dispatch($listing);
return $listing;
}

// Eloquent scope — NL search
public function searchNL(string $query): Collection
{
$filters = $this->claude->parseSearch($query);
return Listing::search($filters)->get();
}
}
listing_handler.go
// Golang — Gin + Clean Architecture

func (h *ListingHandler) CreateListing(
c *gin.Context) {
var cmd CreateListingCmd
if err := c.ShouldBindJSON(&cmd); err != nil {
c.JSON(400, err.Error()); return
}
listing, err := h.useCase.Execute(c, cmd)
if err != nil { c.JSON(422, err); return }

// Goroutine — non-blocking AI
go func() {
desc, _ := h.claude.WriteDescription(cmd)
h.repo.UpdateDesc(listing.ID, desc)
h.search.Index(listing.ID)
}()
c.JSON(201, listing)
}
Go 1.23 Gin Framework pgx / sqlx Next.js 15 testify
Go Stack — High Performance

Golang / Gin
+ Next.js 15

The performance stack for teams prioritising throughput, concurrency, and minimal infrastructure cost. Go's goroutine model handles thousands of concurrent requests with a fraction of the memory footprint of JVM or .NET runtimes — ideal for high-traffic flash sales and real-time marketplaces.

🐹
Goroutines for Concurrent AI ProcessingAI processing, search indexing, and notifications fire as goroutines — never blocking the request path. Thousands of concurrent AI tasks at negligible memory cost per goroutine.
📦
Single Binary DeploymentGo compiles to a single self-contained binary — no runtime, no JVM, no dependency manager in production. Container images start in milliseconds and scale instantly.
💾
~60MB Memory vs 200–500MB for Other StacksGo services run at 50–80MB RAM vs 200MB+ for .NET or Node.js — dramatically lower infrastructure costs at scale. Run 4× more instances on the same hardware budget.
Python Stack — AI/ML Ready

Python / Django 5
+ DRF + Celery

The AI/ML stack for teams extending beyond the Claude API — integrating custom PyTorch models, HuggingFace transformers, scikit-learn pipelines, and NVIDIA GPU acceleration alongside the standard platform. Also the best stack for complex geo-spatial queries via GeoDjango.

🐍
Native ML / AI Pipeline ExtensionPlug in PyTorch, TensorFlow, or HuggingFace transformers alongside Claude AI. Fine-tune recommendation models on your own data, build custom pricing models, and extend the AI layer with any Python ML library.
🌍
GeoDjango — Deepest Geo SupportNative PostGIS via GeoDjango with full GDAL/GEOS support — the most capable geo stack for directory and real estate products with complex polygon search, radius filtering, and school district queries.
⚙️
Celery + Redis — Async AI TasksCelery distributes AI workloads across workers — recommendation rebuilds, demand forecasting, and ML model inference run asynchronously with Flower dashboard for queue monitoring.
Python 3.13 Django 5 DRF Celery + Redis GeoDjango PyTorch Pandas / NumPy pytest
listing_service.py
# Django — DRF + Celery + Claude

class ListingService:
def __init__(self, claude: ClaudeService):
self.claude = claude

def create_listing(self, data: dict) -> Listing:
listing = Listing.objects.create(**data)
# Dispatch async Celery tasks
generate_desc_task.delay(listing.id)
index_listing_task.delay(listing.id)
return listing

# Celery task — Claude + ML
@shared_task
def generate_desc_task(listing_id):
listing = Listing.objects.get(pk=listing_id)
# Claude + optional ML pipeline
desc = claude_write(listing)
listing.update(description=desc)
⚡
Axum / Rust — Coming Q4 2026
The maximum performance stack — zero-cost abstractions, memory safety without GC, sub-5ms cold starts
🔨 In Active Development · Q4 2026
What's Coming
→Axum 0.7 async HTTP handlers
→Tokio runtime for async concurrency
→SQLx compile-time query verification
→Zero-copy request/response processing
→Next.js 15 frontend (same as Go stack)
→All 7 products on day one
Why Rust / Axum?
✓Memory safety without garbage collection
✓~20MB RAM vs 200MB+ for .NET or Node
✓Predictable latency — zero GC pauses
✓Best for real-time auction and bidding
✓Ideal for media streaming at massive scale
✓<5ms cold start in containerised deploys
Stay Informed

The Axum/Rust stack is in active development. Request a demo to be notified when it ships and to discuss early access for your project or client.

Join Early Access →
Expected: Q4 2026 · All 7 products
7-Layer Clean Architecture

Same Structure.
Every Stack.

All 6 stacks implement the identical 7-layer clean architecture. Switching stacks means translating the implementation idioms — not redesigning the architecture. Domain logic, event patterns, and module contracts are identical everywhere.

01
SharedKernel
Base entities, value objects (Money, GeoPoint), domain exceptions, guard clauses, and result pattern. Zero framework dependencies.
02
Domain Layer
Aggregates, domain events, repository interfaces, and business rules. No framework, no infrastructure, fully unit-testable in isolation.
03
Infrastructure Layer
Repository implementations, Stripe / map / email / S3 clients. All I/O lives here — swap any external provider without touching domain logic.
04
Application Layer
CQRS commands/queries, Claude AI pipeline integration, use case orchestration, and domain event publishing via mediator/bus.
05
Search Layer
Elasticsearch indexing, faceted search, geo-spatial queries, full-text search, and Claude NL query parsing — decoupled from domain and API.
06
API Layer
REST and/or GraphQL controllers, JWT + OAuth2 auth, rate limiting, API versioning, OpenAPI docs, and webhook delivery.
07
Web / UI Layer
Angular 21 or Next.js 15 (Vue 3 for Laravel). SSR for SEO pages, template-aware theming, merchant dashboards, and admin panels.
Domain Event — Same Pattern, 4 Stacks
// .NET 10 — Domain Event + Handler

public sealed record ListingPublishedEvent(
Guid ListingId,
string Title,
Money Price
) : IDomainEvent;

// MediatR handler
public class OnListingPublished
: INotificationHandler<ListingPublishedEvent>
{
public async Task Handle(
ListingPublishedEvent e, CancellationToken ct)
{
await _search.IndexAsync(e.ListingId, ct);
await _claude.GenerateMetaAsync(e, ct);
await _alerts.NotifyMatchesAsync(e, ct);
}
}
// NestJS — EventEmitter2 handler

export class ListingPublishedEvent {
constructor(
public readonly listingId: string,
public readonly title: string,
public readonly price: Money,
) {}
}

@OnEvent('listing.published')
async handle(e: ListingPublishedEvent) {
await this.search.index(e.listingId);
await this.claude.generateMeta(e);
await this.alerts.notifyMatches(e.listingId);
}
// Golang — event bus handler

type ListingPublishedEvent struct {
ListingID string
Title string
Price Money
}

func (h *ListingEventHandler) Handle(
ctx context.Context,
e ListingPublishedEvent) error {
// Goroutines — parallel execution
go h.search.Index(e.ListingID)
go h.claude.GenerateMeta(e)
go h.alerts.NotifyMatches(e.ListingID)
return nil
}
# Python — dataclass event + Celery

from dataclasses import dataclass

@dataclass
class ListingPublishedEvent:
listing_id: str
title: str
price: Money

@shared_task
def on_listing_published(listing_id: str):
index_listing(listing_id)
generate_meta(listing_id)
notify_matches.delay(listing_id)
Patterns consistent across all stacks
✓CQRS with mediator / bus
✓Repository pattern
✓Domain events
✓Result pattern (no exceptions)
✓Dependency injection
✓Validation layer
✓Async job queues
✓Structured logging
Stack Comparison

Side-by-Side Feature Matrix

Every stack delivers full feature parity for core business functionality. Differences are in ecosystem, performance characteristics, and specialist capabilities.

Feature / Capability ◆ .NET 10 ◆ NestJS ◆ Laravel ◆ Golang ◆ Django ◆ Axum
Core Platform
7-Layer Clean Architecture✓✓✓✓✓Q4 2026
All 7 Products Included✓✓✓✓✓Q4 2026
REST API✓✓✓✓✓Q4 2026
GraphQL API✓✓––✓–
JWT + OAuth2 + 2FA✓✓✓✓✓Q4 2026
Multi-tenant SaaS Engine✓✓✓✓✓Q4 2026
Claude AI Integration
Claude API Layer✓✓✓✓✓Q4 2026
Async AI ProcessingHangfireBullMQHorizonGoroutinesCeleryTokio
Custom ML Model Extension––––Best ★–
Data & Search
Elasticsearch Integration✓✓Scout✓✓Q4 2026
PostGIS Geo Queries✓Prisma✓pgxGeoDjango ★SQLx
Redis Caching✓✓✓✓✓Q4 2026
Frontend
Admin / Merchant DashboardAngular 21Next.js 15Vue 3Next.js 15Next.js 15Next.js 15
SSR for SEO✓RSC ★InertiaRSC ★RSC ★Q4 2026
Real-Time / WebSocketsSignalR ★Socket.ioEchoWebSocketChannelsQ4 2026
Performance
Throughput (relative)HighMed-HighMediumVery HighMediumMaximum ★
Memory Footprint~200MB~180MB~100MB~60MB~150MB~20MB ★
Cold Start Time~2s~1.5s~0.5s~80ms~1s<5ms ★
Maturity & Support
Years in Production17 yrs ★AvailableAvailableAvailableAvailableQ4 2026
Documentation DepthDeepest ★FullFullFullFullComing
License Included✓✓✓✓✓Q4 2026
★ = Best in class for this capability · All stacks deliver full feature parity for business functionality
Product × Stack Matrix

Every Product. Every Stack.

All 7 products are available in all 5 active stacks today. The Axum/Rust stack ships Q4 2026 with all 7 products on day one. Professional license includes all stacks for a product; the Complete Bundle covers all 7 products × all 6 stacks.

Product .NET 10 NestJS Laravel Golang Django Axum
🏘️ PlacoRealEstate✓✓✓✓✓Q4 2026
📋 PlacoClassifiedAds✓✓✓✓✓Q4 2026
💼 PlacoRecruiter✓✓✓✓✓Q4 2026
🛒 PlacoEcommerce✓✓✓✓✓Q4 2026
📺 PlacoMedia✓✓✓✓✓Q4 2026
📍 PlacoDirectories✓✓✓✓✓Q4 2026
📝 PlacoDMS (CMS+DMS)✓✓✓✓✓Q4 2026
Stack Selection Guide

Which Stack Is Right for You?

Feature parity means you choose based on your team's expertise, infrastructure needs, and ecosystem preferences — not product limitations. Here's the honest guide.

🔷
Choose .NET 10 if...
Your team knows C# · Longest track record
.NET 10 C# 14 Angular 21
You or your clients require the Microsoft / Azure ecosystem
You need complex real-time features (SignalR is the best WebSocket layer)
You want the deepest documentation and longest production track record
Your team has existing .NET / C# expertise and doesn't want to retrain
You're building enterprise-scale platforms for large-company clients
🟢
Choose NestJS if...
TypeScript everywhere · Full-stack JS teams
NestJS 10 TypeScript Next.js 15
Your team writes TypeScript on both frontend and backend today
You want end-to-end type safety with Prisma eliminating runtime DB errors
You're coming from an Angular or Node.js background
You need RSC-powered Next.js 15 frontends with maximum SEO performance
Your team prefers the npm ecosystem over NuGet or Composer
🔴
Choose Laravel if...
PHP teams · Fastest time-to-market
Laravel 11 PHP 8.3 Vue 3
Your team has deep PHP / Laravel expertise and you want to move fast
You want Inertia.js SPA without the complexity of a separate API layer
You need Cashier for subscription billing without writing Stripe boilerplate
Your hosting is optimised for PHP (cPanel, Plesk, shared hosting)
You're building for clients on tight budgets with shared hosting
🐹
Choose Golang if...
Maximum throughput · Minimal infrastructure
Go 1.23 Gin Next.js 15
You're building high-traffic platforms (flash sales, live auctions, marketplaces)
Infrastructure cost is critical — run 4× more instances on the same budget
You want single binary deploys with millisecond container startup
Your team knows Go or wants to move to a modern, performant server language
You need goroutine-based concurrency for large-scale AI processing
🐍
Choose Django if...
AI/ML extension · Geo-spatial · Data science
Python 3.13 Django 5 GeoDjango
You want to extend AI beyond Claude with PyTorch, HuggingFace, or scikit-learn
You're building a real estate or directory product with complex spatial queries
Your team has a Python / data science background
You plan to build and train custom recommendation or pricing models
You want the most capable geo-spatial stack via GeoDjango + PostGIS
⚡
Choose Axum if...
Extreme performance · Memory-critical systems
Rust Axum 0.7 Q4 2026
You need absolute maximum throughput — real-time bidding, live auctions, streaming
Memory constraints are extreme — IoT, embedded, or massively multi-tenant SaaS
You require predictable sub-millisecond latency without GC pauses
Your team already knows Rust or wants to adopt it for competitive advantage
You're building infrastructure-level platforms alongside product features
FAQ

Frequently Asked Questions

Does each stack really have the same features?
Yes — full feature parity is a hard requirement for every release. Every product feature, AI integration, module, and security pattern is implemented in all 5 active stacks simultaneously. The Axum/Rust stack will ship with all features on day one in Q4 2026. Differences are purely in ecosystem tools and performance characteristics, not in product functionality.
Can I buy one stack and upgrade to another later?
Yes. If you purchase a Starter license for one stack, you can upgrade to Professional at any time to unlock all 6 stacks. The price difference is credited. You keep all stacks you purchase permanently with no recurring fees.
Do I get the source code or just compiled binaries?
You receive complete, unobfuscated source code for every stack in your license. The entire 7-layer codebase is yours to read, modify, extend, and deploy as you see fit within your license terms. No compiled-only modules.
Which stack is best for an agency building client projects?
Professional license is the obvious choice for agencies — all 6 stacks with unlimited deployments. Most agencies find they need 2–3 stacks in practice: typically .NET for enterprise clients, NestJS for JavaScript teams, and Laravel for PHP-based hosting environments.
Is the Claude AI integration stack-specific?
No — the Claude AI integration layer is implemented identically in every stack. You provide your Anthropic API key in the config and all AI features (NL search, description generation, valuations, fraud detection, etc.) work the same way regardless of which stack you deploy.
Can I run multiple stacks for the same product in production?
Yes, and some teams do — for example, using the Golang stack as a high-throughput search API while the .NET stack serves the admin dashboard and management APIs. The API contracts are identical across stacks, so they can coexist behind a load balancer.
What database does each stack use?
The .NET stack supports SQL Server and PostgreSQL. NestJS uses PostgreSQL via Prisma. Laravel uses MySQL and PostgreSQL. Golang uses PostgreSQL via pgx/sqlx. Django uses PostgreSQL (required for GeoDjango). All stacks use Elasticsearch for the search layer and Redis for caching and job queues.
When exactly is the Axum/Rust stack available?
The Axum/Rust stack is in active development with a Q4 2026 target. All 7 products will ship simultaneously. Customers who request a demo can be added to the early access list and will be notified as soon as it's available for preview. Pricing will be the same as the other stacks.

Your Stack.
Our Architecture.

Pick the language your team already knows. Get the same 7-layer clean architecture, the same Claude AI integration, and the same complete feature set — whatever stack you choose.

Request Demo View Pricing → Browse Products →