DEV Community: Jorge Peraza

I Replaced GitHub + Jira + Vercel + PlanetScale + Datadog With One Free Platform

Jorge Peraza — Mon, 06 Apr 2026 15:07:29 +0000

Every month I was paying for five tools that didn't talk to each other.

GitHub for code ($20/mo for the team). Jira for tasks ($8/user/mo). Vercel for some deploys ($20/user/mo). A database host ($40/mo). Datadog for monitoring ($75/mo). Plus the Slack tax of context-switching between all of them 50 times a day.

Total: ~$400/month. Five logins. Five billing dashboards. Five permission systems. Zero integration between them.

When someone on my team merged a PR, I had to:

Check GitHub to see the diff
Switch to Jira to update the ticket
Switch to Vercel to see if the deploy succeeded
Switch to Datadog to check if metrics look healthy
Go back to Jira to move the ticket to Done

That's five context switches for one merge. Multiply by 10 merges a day. That's 50 tab switches. Research says each context switch costs 20-30 minutes of deep focus. We were bleeding productivity.

So I Built One Platform

I'm a developer. The answer was obvious: build one tool that does all of it.

MonkeysCloud is what I built. It's a single platform with:

Git hosting — repos, PRs, branches, merge queues, branch protection
Task management — Kanban boards, Scrum sprints, time tracking, labels
Hosting — 32 stacks, auto-detect, auto-build, auto-deploy
Databases — MySQL, PostgreSQL, Redis, MongoDB
AI — code review on every PR, build failure analysis, deploy risk scoring
Documentation — wiki, knowledge base, API docs
Monitoring — metrics, logs, uptime checks, alerts

And here's the part that matters: it's free.

What "Free" Actually Means

Not a 14-day trial. Not "free until you hit 100 builds." Actually free:

What you get	Free tier
Compute instances per project	2 free
Database instances per project	2 free
Team members	Unlimited
Projects	Unlimited
Git repositories	Unlimited
Custom domains + SSL	Yes
AI code review	Yes
Kanban boards + sprints	Yes
Monitoring + logs	Yes
Documentation wiki	Yes

The Part That Changed My Workflow

The killer feature isn't any single thing — it's the integration.

When a developer creates a branch named feature/PROJ-42-auth, the platform automatically links that branch, every commit on it, the PR, the build, the preview environment, and the deploy back to task PROJ-42.

The task timeline shows:

Task created by Sarah
Branch feature/PROJ-42-auth created
4 commits pushed
PR #17 opened
AI review: 2 suggestions (resolved)
Build #84 passed
PR merged to main
Deploy #91 to production ✓
Task auto-moved to Done

Nobody manually updated the task. Nobody copy-pasted a Jira ticket number. Nobody checked three tabs to verify the deploy. It just happened.

My project manager sees the full lifecycle of every feature without asking anyone for a status update. The board moves itself.

The AI Actually Helps

I've been burned by "AI-powered" tools that are just ChatGPT wrappers. MonkeysAI is different because it has context — it accesses the actual codebase, task board, build logs, deploy history, and monitoring data.

When a build fails, it doesn't say "check your configuration." It says:

Build failed: TypeScript type mismatch on line 42 of Auth.tsx. The function handleLogin expects string but receives string | undefined. Introduced in commit abc123. Fix: add a null check or update the type signature.

When I'm about to deploy to production, it gives a risk score:

Deploy risk: MEDIUM. Changes 3 files in the payment module. Test coverage for changed code: 62% (below project average of 78%). Recommendation: verify checkout flow in preview before promoting.

These are not generic suggestions. They reference my actual files, my actual test coverage, my actual deploy history.

32 Stacks — Zero Config

I push code. MonkeysCloud reads composer.json, package.json, go.mod, requirements.txt, Gemfile, Cargo.toml, or whatever — and generates the entire build config automatically.

Stacks I've deployed without writing a single line of configuration:

PHP: Laravel, Symfony, WordPress, Drupal, my own MonkeysLegion framework
JavaScript: Next.js, Nuxt, Remix, SvelteKit, Astro, Express, NestJS, React, Vue, Angular
Python: Django, FastAPI, Flask, Streamlit
Ruby: Rails
Go: any Go project (compiles to binary, 30-second deploys)
Rust: Actix, Axum, Rocket
Java: Spring Boot
.NET: ASP.NET Core
Elixir: Phoenix
Custom: Dockerfile, Docker Compose

You can override everything, but for 90% of projects, you push code and it just works.

What It Costs (For Real)

Solo developer, side project: $0/month. Two free servers + two free databases. Custom domain. AI code review. Task board.

Going to production: $19/month. One always-on Starter instance. Keep your free instances for dev and staging.

Startup, 5 devs, 2 projects: ~$177/month. Team plan ($59) + Pro production ($79) + Plus database ($39). Everything else free. Compare to $400+ across five separate tools.

Agency, 12 clients: ~$135/month. Most clients on free instances. A few on Starter ($19 each). Team plan ($59). All client stakeholders invited free.

Try It

Push your code and get a live URL in 60 seconds: monkeys.cloud

I built this because I was tired of context-switching between five tools that cost $400/month combined. Now my entire workflow — code, tasks, deploys, databases, AI, docs, monitoring — lives in one place.

If you've felt the same frustration, give it 5 minutes. The worst that happens is you deploy a project for free.

I'm Jorge, the founder of MonkeysCloud. I'm building this in public and shipping fast. Follow along or roast my work — either way, I'd love to hear what you think in the comments.

We're Giving Away Free Servers With Every Project — App, Database, Cache, Worker. No Trial. No Credit Card.

Jorge Peraza — Sun, 05 Apr 2026 21:16:28 +0000

Today we're launching something that no other developer platform offers: every project you create on MonkeysCloud gets free compute instances and free database instances. Not a 30-day trial. Not $5 in credits. Real servers that run your code and your database — for as long as you need them.

Here's what that means in practice.

What You Get — Per Project, No Strings

Every project on MonkeysCloud includes:

Instance	What it runs	Size	Cost
Free server 1	Your application (any of 32 stacks)	1 GB RAM	$0
Free server 2	A worker, second service, or another app	1 GB RAM	$0
Free database 1	MySQL 8.4, PostgreSQL 16, or MongoDB 7	1 GB RAM	$0
Free database 2	Redis 7 cache, or a second database	1 GB RAM	$0

That's 4 free instances per project. Each one can run any role — app server, database, cache, queue worker, scheduler, or a custom Docker container. You choose.

No credit card required. No time limit. No usage cap. You sign up, create a project, select your stack, push code, and you have a running application with a database and a cache at a live URL.

What Exactly Runs on These Free Instances?

Let me make this concrete. Here's what you can deploy right now for $0:

A complete Laravel stack:

Instance 1: Laravel app (FrankenPHP, PHP 8.4)
Instance 2: Queue worker (processing jobs)
Database 1: MySQL 8.4 (your primary database)
Database 2: Redis 7 (sessions + cache)

Total cost: $0. That's a production-capable Laravel application with a relational database, a cache layer, and background job processing.

A Next.js full-stack app:

Instance 1: Next.js (Node 22, SSR)
Database 1: PostgreSQL 16
Database 2: Redis 7

Total cost: $0. Three instances. Full-stack JavaScript with a real database.

A Django + Celery setup:

Instance 1: Django (Gunicorn)
Instance 2: Celery worker
Database 1: PostgreSQL 16
Database 2: Redis 7 (Celery broker)

Total cost: $0. Background tasks, a real database, and a message broker.

A microservices project:

Instance 1: Go API
Instance 2: Node.js service
Database 1: PostgreSQL 16
Database 2: MongoDB 7

Total cost: $0. Two services and two different database engines.

Every project. Any stack. App + database + cache + worker. Free.

The Fine Print (There's Not Much)

Sleep after 30 minutes. Free instances sleep after 30 minutes with no incoming traffic. When the next request arrives, the instance wakes in 3 to 5 seconds. Your data on disk — database files, uploaded files, application state — is preserved while sleeping. This is fine for development, staging, demos, internal tools, client previews, and sites with intermittent traffic.

Custom domains and SSL work. Every instance — including free ones — supports custom domains with auto-provisioned SSL via Let's Encrypt. You can point myapp.com at a free instance and it works.

Two sizes of free. There are actually two free sizes:

Size	CPU	RAM	SSD	Cost
Free	Shared 0.25 vCPU	1 GB	1 GB	$0
Starter	Shared 0.5 vCPU	2 GB	10 GB	$0

Both are free. Both sleep after 30 minutes. Both count toward your free instance quota. Pick whichever fits your workload.

2 + 2 is the starting point. A free account gets 2 compute instances + 2 database instances per project. But that quota grows as you add paid instances (more on that below).

The Platform Is Free Too

The free instances are just the infrastructure. The platform that wraps them is also free:

Git hosting. Unlimited private repositories with Smart HTTP and SSH access. Or mirror from GitHub, GitLab, or Bitbucket.

Pull requests. Create PRs, leave inline reviews, run merge queues, enforce branch protection. Three merge strategies: merge commit, squash, rebase.

AI code review. Every PR gets an automated review in seconds — security vulnerabilities, performance issues, bugs, and best practices. Inline comments with suggested fixes. Before your team even opens the PR.

Task management. Kanban boards and Scrum sprints. Tasks auto-link to branches, PRs, builds, and deploys through branch naming. The board updates itself — nobody manually moves tickets to "Done."

Monitoring. Response times, error rates, CPU, memory, bandwidth — real-time dashboards with zero setup. Structured log viewer with search and live streaming.

Documentation. Built-in Markdown wiki with version history, search, and collaborative editing. API docs, runbooks, onboarding guides — next to your code and tasks.

Unlimited team members. Invite your entire team — developers, designers, product managers, clients, contractors. Everyone gets full access. No per-seat pricing. No "viewer" seats. Free.

How It Scales: The Tier System

Here's the part I'm most proud of. When you add a paid instance (Plus at $39/mo or above) to any project, your entire organization gets upgraded:

Paid Instances in Org	Org Tier	Max Projects	Free Instances per Project
0	Free	2	2 + 2
1	Starter	5	3 + 3
2–3	Growth	10	4 + 4
4–7	Pro	20	5 + 5
8–15	Business	50	6 + 6
16–30	Scale	100	7 + 7
31+	Enterprise	Unlimited	7 + 7

One paid instance upgrades every project. Add a single Plus ($39/mo) to Project A, and Projects B, C, D, and E all get 3 free compute + 3 free database instances each. The paid instance benefits your entire org, not just the project it lives in.

And here's the kicker: Plus, Pro, and Business include a 90-day free trial. You add a Plus instance, pay $0 for 90 days, and immediately get Starter tier benefits across your entire organization. Five projects. Three free instances each. Before paying a single dollar.

32 Stacks — You Pick, We Build

When you create a project, you select your stack from 32 options. MonkeysCloud generates the complete build configuration — base image, install commands, build steps, start command — based on your selection. Push code. We handle the rest.

PHP: Laravel, Symfony, WordPress, Drupal, MonkeysLegion, PHP Generic
JavaScript/TypeScript: Next.js, Nuxt, Remix, SvelteKit, Astro, Express, NestJS, React SPA, Vue SPA, Angular
Python: Django, FastAPI, Flask, Streamlit, Python Generic
Ruby: Rails, Ruby Generic
Go
Rust
Java: Spring Boot, Java Generic
.NET
Elixir: Phoenix
Other: Static Site, Docker, Docker Compose

You pick the stack. We configure the build pipeline. You push code. It deploys.

What It Costs When You Need More

The free tier handles development, staging, demos, and low-traffic production. When you need always-on instances with more compute for real production traffic:

Size	RAM	SSD	Price	Always-On
Free	1 GB	1 GB	$0	No (sleeps)
Starter	2 GB	10 GB	$0	No (sleeps)
Plus	4 GB	25 GB	$39/mo (90 days free)	Yes
Pro	8 GB	60 GB	$79/mo (90 days free)	Yes
Business	16 GB	120 GB	$149/mo (90 days free)	Yes
Scale	32 GB	250 GB	$299/mo	Yes
Power	64 GB	500 GB	$599/mo	Yes
HC-32 → HC-64	128–256 GB	1–2 TB	$1,199–$2,399/mo	Yes

The jump from free to paid is Plus at $39/month — with 90 days free. That gives you 4 GB RAM, 25 GB SSD, always-on, and immediately upgrades your org tier so every project gets more free instances.

Who This Is For

Solo developers. Deploy your side project, portfolio, or MVP with a database. Free. Custom domain. SSL. AI code review. Push to deploy.

Startups. Run your development and staging environments on free instances. Add a Pro ($79, 90 days free) for production. Your 5-person team uses the platform for free — Git, tasks, deploys, monitoring, docs. Compare to $400/month across GitHub + Jira + Vercel + database host + Datadog.

Agencies. Create a project per client. Most client sites run on free instances with a custom domain. Larger clients upgrade to Plus or Pro for always-on. Invite client stakeholders to their project board for free. Fifteen developers, twelve clients — all free.

Open-source projects. Host your project, track issues, deploy documentation sites, and give contributors AI-reviewed PRs. Free. Apply for our Open Source Partner program for additional instance credits and a free Team plan.

Students and educators. Learn real-world dev workflows — Git, pull requests, CI/CD, databases, monitoring — on a platform that doesn't expire after 30 days. Apply for our Education Partner program for free Team plans and instance credits.

Try It Right Now

No pitch. No "schedule a demo." No "talk to sales."

Go to monkeys.cloud
Sign up (GitHub or Google, 10 seconds)
Create a project, select your stack
Push your code
You have a live URL with a database

The worst that happens is you deploy a project for free and decide it's not for you.

The best that happens is you replace five tools with one and never context-switch again.

→ monkeys.cloud

FAQ for the Skeptics

"How do you make money if the servers are free?"

The free instances are small (1–2 GB) and sleep when idle. They cost us very little to run on shared infrastructure. When your project needs always-on production hosting with dedicated compute and more resources, you add paid instances starting at $39/month with 65–79% gross margins. The free tier is the acquisition funnel. The paid tier is the business.

"What's the catch?"

Free instances sleep after 30 minutes. That means a 3–5 second wake time on the first request after sleeping. For production sites where every millisecond matters, you upgrade to a paid always-on instance. For everything else — dev, staging, demos, internal tools, side projects, client previews — the sleep/wake cycle is fine.

"Will the free tier disappear?"

We reserve the right to modify free tier limits with 30 days' notice (see our Terms). We have no plans to remove the free tier — it's our primary acquisition channel and the core of our growth model. But we're honest: we don't use the phrase "free forever" because we can't predict the future. What we can say is that the free tier is fundamental to how MonkeysCloud works, and removing it would require fundamentally changing the business.

"How is this different from Railway/Render/Heroku?"

Railway gives you a 30-day trial with $5 credit — then you pay per minute. Render's free tier sleeps after 15 minutes with 750 hours/month. Heroku eliminated free dynos entirely. None of them include Git hosting, task management, AI code review, documentation, or monitoring. MonkeysCloud gives you all of that — plus 4 free instances per project — in one integrated platform.

"How is this different from Vercel/Netlify?"

Vercel and Netlify are frontend-first. They deploy React, Next.js, and static sites. They don't host PHP, Python, Go, Ruby, Java, or Rust backends. They don't run MySQL, PostgreSQL, or Redis. They don't have task management or AI code review. MonkeysCloud is full-stack — 32 frameworks, real databases, real backend hosting.

"Can I actually run a production site on the free tier?"

If your site gets intermittent traffic and a 3–5 second wake time is acceptable, yes. Many blogs, portfolios, documentation sites, internal tools, and low-traffic client sites run fine on free instances with a custom domain and SSL. For high-traffic production with instant response, upgrade to Plus ($39/mo, 90 days free).

I'm Jorge, the founder of MonkeysCloud. I built this because I was tired of paying $400/month for five tools that didn't talk to each other. Now I'm giving away free servers to every developer who wants to ship faster. Questions, feedback, or roasts — drop them in the comments. I read every one.

Stop Bidding Against 200 People for $5 Projects — There's a Better Way

Jorge Peraza — Tue, 10 Mar 2026 03:08:13 +0000

If you've spent any time on traditional freelance platforms, you know the drill.

You find a project that fits your skills perfectly. You spend 30 minutes crafting a thoughtful proposal. You hit submit — and immediately see you're proposal #47 out of 50 slots. Half of them are undercutting you by 80%. The client ghosts everyone and reposts the job two weeks later.

It's exhausting. And it doesn't have to be this way.

Introducing MonkeysWorks — An AI-Powered Freelance Marketplace Built for Developers

MonkeysWorks is a new kind of freelance platform launching soon, and we're opening the doors early for freelancers who want to get in before the crowd.

👉 Join the Prelaunch Waitlist as a Freelancer

What Makes MonkeysWorks Different?

🤖 AI Does the Heavy Lifting

MonkeysWorks uses AI at every step of the process — not as a gimmick, but to genuinely save you time and surface the right opportunities.

Smart job matching that learns your skills, stack, and preferences
AI-assisted proposals so you spend time doing the work, not selling it
Automated project scoping to help clients define what they actually need before they post

No more sifting through 300 irrelevant listings looking for the one real opportunity.

💻 Built by Developers, for Developers

MonkeysWorks isn't a generic gig marketplace. It's designed for technical freelancers — developers, DevOps engineers, architects, and technical writers — who build real things and deserve to be compensated accordingly.

The platform supports the full modern stack and understands the difference between "build me a website" and "I need a Next.js frontend with SSR, integrated with a headless CMS and deployed on GCP."

💰 Transparent, Fair Pricing

No race to the bottom. MonkeysWorks is designed to reward quality and expertise, not whoever submits the cheapest bid in the first 10 minutes.

Clients on the platform are vetted and come ready to pay fair rates for serious work.

🚀 Get In Early — Early Freelancers Win

Platforms reward early adopters. Getting in before launch means:

Higher visibility when clients start posting
Priority access to the first wave of projects
Influence over platform features — we genuinely listen to early members
Founding member status with perks we're still cooking up

Who Should Join?

MonkeysWorks is a great fit if you are:

A full-stack or backend developer (PHP, Node, Python, Go, you name it)
A frontend developer working with React, Vue, or Next.js
A DevOps / cloud engineer comfortable with GCP, AWS, or containerized workloads
A technical freelancer tired of platforms that treat you like a commodity

If you're serious about your craft and want to work with clients who respect that — this is for you.

How to Join

It takes less than a minute.

→ Sign up at monkeysworks.com/join/freelancers

Leave your info, tell us a bit about your stack, and we'll reach out before the public launch with early access details.

The Bottom Line

The freelance market isn't broken because there isn't enough work. It's broken because the platforms that connect freelancers to clients were built to maximize transaction volume — not freelancer success.

MonkeysWorks is being built differently. AI-first, developer-focused, and designed so that the best person for the job actually gets it.

Come build with us.

Join the MonkeysWorks Prelaunch →

Have questions or want to share feedback? Drop a comment below — the team reads everything.

MonkeysAI — Live Playground (Development Preview)

Jorge Peraza — Fri, 13 Feb 2026 04:24:10 +0000

We just launched something we've been building quietly inside the Monkeys ecosystem:

👉 MonkeysAI — Live Playground

This isn't a wrapper around a third-party API.

There are:

No OpenAI tokens
No external proxy layer
No hidden API dependency

It runs on our own infrastructure.

What Is MonkeysAI?

MonkeysAI is the AI layer for MonkeysCMS and MonkeysLegion — designed to integrate AI directly into content workflows at the architecture level.

Not as a plugin. Not as a SaaS add-on. As core infrastructure.

The Live Playground exposes the API directly in the browser so developers can test behavior before integrating it.

What You Can Do in the Playground

🧠 Generate
Create new content from a short brief.

✨ Improve
Enhance clarity, tone, structure, or formatting of existing content.

🔎 Critique & Refine
Analyze content and automatically improve weak sections.

Smart Model Routing

One of the key pieces we built is dynamic model selection.

Instead of forcing users to choose a model manually, we route intelligently:

⚡ Fast Mode → Optimized for speed and lightweight generation
🧠 Reasoning Mode → Used for deeper analysis and structured logic
🎯 Auto Mode → Automatically selects the best model for the task

This allows:

Lower cost per request
Faster response times when complexity isn't required
Heavy reasoning only when necessary

Why Build It This Way?

Most AI integrations today:

Proxy requests to external APIs
Add latency
Lock you into vendor pricing
Break when token limits change

We wanted:

Infrastructure control
Predictable performance
Cost transparency
Full integration into CMS-level workflows

This approach required:

Custom orchestration
Model routing logic
Dedicated servers
Continuous dataset crawling & validation

It's slower to build — but architecturally cleaner.

Development Preview Notice

This is an early public preview.

We are actively improving:

Response quality
Crawling verification accuracy
Performance optimization
Output stability under load

It's not polished. But it's real.

What's Next?

The Playground is just step one.

The goal is deeper AI-native CMS features like:

Inline multilingual optimization (25+ languages)
Structured content reasoning
SEO-aware generation
AI-assisted migrations
Editorial workflow automation

Try It

If you're building:

A CMS
An AI product
A content engine
Or your own LLM infrastructure

I'd genuinely love feedback.

Try it. Stress it. Break it. Tell me what to improve.

👉 monkeyscms.com/#ai-playground

— Jorge

MonkeysLegion GraphQL 2.0 — A Complete Rewrite, Built for the Future

Jorge Peraza — Wed, 11 Feb 2026 22:30:05 +0000

When I started working on MonkeysLegion GraphQL, the goal was simple:
Make GraphQL feel native to modern PHP.

Version 2.0 is not an upgrade.
It's a complete architectural rewrite.

👉 Repo: MonkeysLegion-GraphQL

Why a Complete Rewrite?

GraphQL in PHP often feels:

Too coupled to webonyx
Configuration-heavy
Reflection-expensive
Hard to secure properly
Difficult to scale for real production workloads

So instead of patching the old system… I rebuilt it from scratch.

What's New in 2.0

🧩 Attribute-Driven Schema Definition

No more schema arrays. No more manual wiring.
Everything is powered by PHP 8.4 attributes.

#[Type]
class UserType
{
    #[Field]
    public function id(): int {}

    #[Field]
    public function name(): string {}
}

#[Query]
class UserQuery
{
    #[Field]
    public function user(#[Arg] int $id): User {}
}

Supported attributes:

#[Type] · #[Field] · #[Query] · #[Mutation] · #[Subscription] · #[Arg] · #[InputType] · #[Enum] · #[InterfaceType] · #[UnionType] · #[Middleware]

Clean. Typed. Explicit.

⚙️ New Architecture (Builder Pipeline)

The entire schema generation system is now modular:

SchemaBuilder
TypeBuilder
FieldBuilder
InputTypeBuilder
EnumBuilder
ArgumentBuilder

No magic factory classes. No static schema definitions. Just a clean build pipeline.

🧠 GraphQLContext (Immutable Execution Context)

Every request now gets an immutable execution context — HTTP request, authenticated user, DI container, and DataLoaderRegistry:

$context = new GraphQLContext(
    request: $request,
    user: $user,
    container: $container
);

Predictable. Safe. Testable.

🚀 Performance: DataLoader + Batch Execution

DataLoader — per-request caching + batching. No more N+1 query nightmares.

abstract class DataLoader {
    abstract protected function batchLoad(array $keys): array;
}

Per-request caching
Batch loading
Registry-based resolution

BatchExecutor — supports multiple operations in one request. Useful for complex clients, microfrontend architectures, and optimized API gateways.

🔒 Security Built-In

Security is not optional anymore. MonkeysLegion GraphQL 2.0 includes:

DepthLimiter
ComplexityAnalyzer
IntrospectionControl
PersistedQueries
RateLimiter

Production-ready from day one.

🧱 Custom Scalars Included

Out of the box support for: DateTime · JSON · Email · URL · Upload

No need to reimplement common scalars.

🔄 Subscriptions (Modern Protocol)

WebSocket layer completely rewritten.

❌ Removed subscriptions-transport-ws
✅ Now using graphql-ws

New components:

SubscriptionServer
SubscriptionManager
PubSubInterface
InMemoryPubSub / RedisPubSub
WsAuthenticator

Removed heavy dependencies like Ratchet/React. Cleaner. Faster. Modern.

🗂 Schema Caching (PSR-16)

Reflection is expensive. So we cache it.

SchemaCache
SchemaCacheWarmer

CLI commands:

php mlc graphql:cache:warm
php mlc graphql:cache:clear

Zero-runtime schema rebuilds in production.

🧾 Input Validation System

Built-in validation layer with InputValidator and RuleSet. Structured validation errors via ValidationError and AuthorizationError.

No need to plug external validation unless you want to.

🔌 PSR-15 Middleware Support

Fully PSR-15 compatible:

GraphQLMiddleware
GraphiQLMiddleware
UploadMiddleware

Drop into any modern PHP stack.

🧬 Entity Integration

Native support for mapping domain entities via EntityTypeMapper and EntityResolver.

Makes MonkeysLegion's entity system work seamlessly with GraphQL.

🔗 Relay Pagination Support

ConnectionType · EdgeType · PageInfoType

Ready for modern frontend clients.

🧰 CLI Tooling

Built-in CLI commands:

graphql:schema:dump
graphql:schema:validate
graphql:cache:warm
graphql:cache:clear
graphql:introspect

GraphQL now feels like a first-class framework citizen.

⚠️ Breaking Changes

This is version 2.0 for a reason.

Changed:

What	Before → After
Minimum PHP version	→ 8.4
WebSocket protocol	→ graphql-ws
Configuration	→ .mlc files (typed)
Types	No longer extend webonyx base classes

Removed:

Schema\SchemaFactory
Support\Scanner
Execution\Executor
WebSocket\WsHandler
Ratchet/React dependencies

Everything replaced with cleaner architecture.

Why This Matters

This release is about performance, security, modern PHP design, clean architecture, and production-readiness.

It's not just "GraphQL working in PHP."
It's GraphQL designed for serious applications.

What's Next?

Federation support
Advanced query cost modeling
Observability hooks
Native OpenTelemetry integration
Extended subscription drivers

Final Thoughts

MonkeysLegion GraphQL 2.0 is the foundation for everything I'm building next — AI-native CMS (MonkeysCMS), scalable SaaS APIs, real-time systems, and high-performance microservices.

Rewriting it was painful. But worth it.

If you're building serious PHP applications and want modern GraphQL done right:

👉 MonkeysLegion-GraphQL on GitHub

MonkeysLegion: Ship Production-Ready PHP in Minutes, Not Days 🚀

Jorge Peraza — Wed, 28 Jan 2026 23:51:09 +0000

TL;DR: MonkeysLegion is a lightweight, modular PHP framework that bundles everything you need—blazing-fast router, DI container, CLI tools, and zero-config Docker—so you can focus on features instead of plumbing. It's MIT-licensed, open-source, and we're looking for collaborators!

Why Another PHP Framework?

Let's be honest: setting up a new PHP project can feel like assembling IKEA furniture without instructions. You need routing, dependency injection, database migrations, authentication, validation, caching... and by the time you've wired it all together, you've lost the motivation to build the actual thing.

MonkeysLegion changes that.

We built it because we were tired of the boilerplate. We wanted something that's:

⚡ Fast to start — One composer command, and you're coding
🧩 Modular — Use only what you need
🔒 Production-ready — Built-in auth, validation, caching, and observability
📖 Well-documented — Because code without docs is just legacy waiting to happen

Get Started in 60 Seconds

composer create-project monkeyscloud/monkeyslegion-skeleton my-app
cd my-app
cp .env.example .env
php ml key:generate
composer serve

Open http://127.0.0.1:8000 — you're live. 🎉

What's in the Box?

MonkeysLegion isn't just another micro-framework. It's a complete ecosystem:

Category	What You Get
HTTP Stack	PSR-7/15 compliant, middleware pipeline
Routing	Attribute-based, auto-discovery, caching
Database	Query Builder, Micro-ORM, Migrations
Auth	JWT, RBAC, 2FA, OAuth, API Keys
Validation	DTO binding with attribute constraints
Caching	File, Redis, Memcached drivers
CLI	Migrations, scaffolding, Tinker REPL
Telemetry	Prometheus metrics, distributed tracing

Code That Speaks for Itself

Attribute-Based Routing

No more giant route files. Define routes right where they belong:

use MonkeysLegion\Router\Attributes\Route;
use MonkeysLegion\Router\Attributes\RoutePrefix;
use MonkeysLegion\Router\Attributes\Middleware;

#[RoutePrefix('/api/users')]
#[Middleware(['cors', 'throttle'])]
class UserController
{
    #[Route('GET', '/', name: 'users.index')]
    public function index(): Response
    {
        return $this->json(User::all());
    }

    #[Route('GET', '/{id:\d+}', name: 'users.show')]
    public function show(string $id): Response
    {
        return $this->json(User::find($id));
    }

    #[Route('POST', '/', name: 'users.create')]
    #[Middleware('auth')]
    public function create(CreateUserRequest $request): Response
    {
        // Validated DTO is automatically injected
        $user = User::create($request->validated());
        return $this->json($user, 201);
    }
}

Validation with DTOs

Type-safe request validation using PHP attributes:

use MonkeysLegion\Validation\Attributes as Assert;

final readonly class CreateUserRequest
{
    public function __construct(
        #[Assert\NotBlank]
        #[Assert\Email]
        public string $email,

        #[Assert\NotBlank]
        #[Assert\Length(min: 8, max: 64)]
        public string $password,

        #[Assert\Url]
        public ?string $website = null,
    ) {}
}

Invalid requests automatically return structured errors:

{
  "errors": [
    { "field": "email", "message": "Value must be a valid e-mail." },
    { "field": "password", "message": "Minimum length is 8 characters." }
  ]
}

Fluent Query Builder

Write readable database queries without raw SQL:

$users = $qb->from('users')
    ->leftJoin('profiles', 'p', 'p.user_id', '=', 'users.id')
    ->select(['users.*', 'p.avatar'])
    ->where('status', '=', 'active')
    ->whereIn('role', ['admin', 'editor'])
    ->orderBy('created_at', 'DESC')
    ->paginate(page: 1, perPage: 20);

Built-in Authentication

JWT auth with 2FA support, ready to use:

$result = $auth->login($email, $password, $request->ip());

if ($result->requires2FA) {
    return response()->json([
        'requires_2fa' => true,
        'challenge' => $result->challengeToken,
    ]);
}

return response()->json([
    'access_token' => $result->tokens->accessToken,
    'refresh_token' => $result->tokens->refreshToken,
]);

Powerful CLI Tools

Scaffold your app without leaving the terminal:

php ml make:entity User          # Generate Entity
php ml make:controller User      # Generate Controller
php ml make:migration            # Generate migration from entity diff
php ml migrate                   # Run migrations
php ml tinker                    # Interactive REPL
php ml openapi:export            # Export OpenAPI spec

The Package Ecosystem

MonkeysLegion is built as independent packages. Use the full stack or pick what you need:

monkeyslegion-core — Kernel, events, helpers
monkeyslegion-router — Full-featured routing
monkeyslegion-auth — JWT, RBAC, 2FA, OAuth
monkeyslegion-query — Query Builder & ORM
monkeyslegion-cache — PSR-16 multi-driver cache
monkeyslegion-files — File storage, chunked uploads, S3
monkeyslegion-mail — SMTP, templates, DKIM, queues
monkeyslegion-i18n — Internationalization
monkeyslegion-telemetry — Metrics & tracing
monkeyslegion-validation — DTO validation
monkeyslegion-template — MLView templating engine

Requirements

PHP 8.4+
MySQL 8.4 (recommended)
Composer 2.x

We Need You! 🤝

MonkeysLegion is open-source and MIT-licensed. We're actively looking for collaborators who want to:

🐛 Report bugs and suggest features
📝 Improve documentation
🧪 Write tests
💡 Build new packages
🌍 Help with translations

No contribution is too small. Whether it's fixing a typo or implementing a new feature, we'd love to have you on board.

Join Our Community

We've set up a Slack workspace where you can:

Ask questions and get help
Discuss features and architecture
Share what you're building
Connect with other developers

👉 Join MonkeysLegion on Slack

Resources

🌐 Website: monkeyslegion.com
📚 Documentation: monkeyslegion.com/docs
💻 GitHub: MonkeysCloud/MonkeysLegion-Skeleton
📦 Packagist: monkeyscloud/monkeyslegion-skeleton

Get Started Now

composer create-project monkeyscloud/monkeyslegion-skeleton my-app

Give it a ⭐ on GitHub if you like what you see!

Built with 💚 by developers who believe PHP deserves better tooling.

What do you think? Have you tried MonkeysLegion? What features would you like to see? Drop a comment below or join us on Slack! 👇

🧠 MonkeysCMS: An AI-Native CMS Built on MonkeysLegion — Rethinking Content Platforms from the Core

Jorge Peraza — Wed, 07 Jan 2026 02:12:47 +0000

Most CMS platforms are built on top of frameworks they don't control.

That single fact explains why:

Extensibility feels bolted-on
Performance tuning is painful
AI integration feels awkward
Developer experience degrades over time

MonkeysCMS exists because we chose a different path.

Instead of adapting a CMS to a framework,
we built a framework specifically to power a modern, AI-native CMS.

That framework is MonkeysLegion.

👉 CMS repo: https://github.com/MonkeysCloud/MonkeysCMS

👉 Framework ecosystem: https://github.com/MonkeysCloud

🚨 Why Existing CMS Architectures Hit a Ceiling

Modern content systems must handle:

Headless & hybrid rendering
API-first delivery
Multi-channel publishing
Automation-heavy workflows
AI-assisted content creation
Long-term maintainability

Yet most CMS platforms fall into one of these traps:

❌ Legacy CMS (Drupal, WordPress, etc.)

Powerful but heavy
Tight coupling everywhere
AI added as plugins
Framework constraints leak into CMS logic

❌ Modern SaaS Headless CMS

Closed source
Usage-based pricing explosions
Limited extensibility
No control over core behavior

The missing piece?

A CMS built on a framework designed explicitly for content systems and automation.

🐒 Enter MonkeysLegion: The Foundation

MonkeysLegion is a modern, modular backend framework built with one goal:

Give developers full control over architecture without sacrificing productivity.

It is:

Lightweight
Explicit
Modular
Framework-agnostic
Built for APIs, automation, and extensibility

MonkeysCMS is not using MonkeysLegion accidentally —
it is a direct expression of its design philosophy.

🏗️ Why Build a CMS on Its Own Framework?

Because CMSs are not just CRUD apps.

They need:

Strong domain modeling
Pluggable logic layers
Predictable extension points
Performance control
AI integration at the core

MonkeysLegion provides:

🧱 Modular packages (Router, Auth, Cache, Query, CLI, etc.)
🔌 Clean dependency boundaries
🧠 Explicit data flow (no magic globals)
🧪 Testable components by default

This lets MonkeysCMS stay:

Clean
Maintainable
Extensible without hacks

🧩 Architecture Overview: CMS + Framework + AI

Think of the system like this:

┌─────────────┐
│   Frontend  │  (Next.js, Astro, Svelte, Apps)
└─────▲───────┘
      │ API
┌─────┴───────┐
│  MonkeysCMS │  Content, Schemas, Workflows
└─────▲───────┘
      │ Core Services
┌─────┴───────┐
│ MonkeysLegion│  Routing, Auth, Storage, CLI
└─────▲───────┘
      │ Intelligence
┌─────┴───────┐
│  MonkeysAI  │  AI workflows & automation
└─────────────┘

Each layer has one responsibility — and nothing leaks.

🧠 MonkeysAI: AI Where It Actually Belongs

Because MonkeysCMS is built on MonkeysLegion, AI isn't a hack.

MonkeysAI integrates cleanly into:

Content pipelines
Workflow automation
Schema interpretation
Semantic enrichment

This enables:

Context-aware content suggestions
AI-assisted editing (not replacement)
Automated content operations
Future schema-aware generation

AI becomes a system capability, not a plugin checkbox.

🛠️ Developer Experience Is a First-Class Feature

MonkeysLegion enforces discipline that benefits MonkeysCMS developers:

No hidden container magic
No global state abuse
Clear service contracts
Predictable lifecycle

As a contributor, this means:

You can understand modules in isolation
You don't need to learn "CMS magic"
Your changes don't break unrelated systems

If you've ever said:

"I hate fighting the framework just to add a feature"

This stack was built for you.

📦 Modular by Nature (Not by Marketing)

Because MonkeysCMS inherits MonkeysLegion's modularity:

Every CMS feature is a module
AI capabilities are pluggable
APIs are versionable
Integrations are isolated

This makes:

Custom deployments easy
Enterprise use viable
Long-term maintenance realistic

No forks. No hacks. No rewrites.

🌍 Real-World Use Cases

This architecture is ideal for:

AI-driven content platforms
SaaS documentation hubs
Multi-brand editorial systems
Investor/startup platforms
Knowledge bases & research portals
CMS + automation hybrids

Anywhere content needs to be structured, automated, and intelligent.

🧑‍💻 Contributing: CMS, Framework, or AI

You don't need to contribute to everything.

You can help with:

MonkeysCMS features
MonkeysLegion core packages
MonkeysAI workflows
Documentation
DX improvements
Integration examples

This is an ecosystem — not a monolith.

👉 Start here: https://github.com/MonkeysCloud/MonkeysCMS

🛣️ What's Ahead

Roadmap highlights:

Visual schema builders
AI-powered content ops
Plugin marketplace
Advanced workflow automation
Multi-tenant support
Performance-focused deployments

All driven by MonkeysLegion's stability and AI-native design.

🧠 Final Thought

MonkeysCMS is not "just another CMS".

It is:

A CMS powered by its own framework
An AI-native content platform
A long-term open-source ecosystem

Framework first. CMS second. AI everywhere it makes sense.

If this vision resonates:

⭐ Star the repo
🧠 Join the discussions
🧑‍💻 Build with us

Let's build the CMS — and the foundation beneath it — the right way 🐒🚀

MonkeysCMS + MonkeysAI: Building the First AI-Native Open CMS 🚀

Jorge Peraza — Sat, 03 Jan 2026 02:58:47 +0000

A few weeks ago, I shared an article about MonkeysCMS and the idea of building the CMS we always wanted.
The response was clear: many of us feel the same frustration with today's CMS landscape.

Now, the journey is taking its next step.

We're actively developing MonkeysAI, and it's not a side project. It's becoming a core part of MonkeysCMS.

This document is an invitation — not just to use another CMS, but to help define the first truly AI-native,
developer-first open CMS.

Why AI Inside the CMS

Most CMS platforms treat AI as a plugin, an external API call, or a paid add-on.
We're doing the opposite.

MonkeysAI is designed as part of the CMS architecture, so AI works with your content model, not around it.

That means:

AI that understands your content types
Context-aware generation
SEO optimization inside the editor
Full control for teams

What MonkeysAI Brings

AI-assisted content creation:

Draft generation from structured fields
Rewrite, expand, summarize, localize
Consistent tone and brand voice

SEO as a first-class citizen:

Title and meta generation
Semantic keyword suggestions
Readability and structure feedback

Structured, not magical:

Respects schemas and taxonomies
Developers decide where AI is allowed
Editors stay in control

Open and extensible:

No vendor lock-in
Pluggable providers
Production-ready design

Why Build in the Open

MonkeysCMS is not another WordPress clone or a closed SaaS.
It's a framework-driven CMS built for developers who care about architecture and clean APIs.

AI should enhance control, not replace it.

Who Should Join

We welcome:

Backend and frontend developers
AI engineers
CMS architects
SEO specialists and writers
Open-source contributors

You don't need to know everything — just care about building something better.

Early Stage, Real Impact

MonkeysCMS + MonkeysAI is still being shaped.
Early contributors will influence architecture and define how AI fits real CMS workflows.

Join the Journey

Repository: https://github.com/MonkeysCloud/MonkeysCMS

We're building the next generation of content systems — open, intelligent, and human-centric.

Built on: MonkeysLegion Framework

Questions? Drop a comment below or open an issue on GitHub. Let's build something great together.

Slack: https://join.slack.com/t/monkeyslegion/shared_invite/zt-36jut3kqo-WCwOabVrVrhHBln4xhMATA

Build the CMS we always wanted: MonkeysCMS (contributors wanted)

Jorge Peraza — Sun, 21 Dec 2025 22:57:57 +0000

There are two kinds of CMS projects:

The ones that are easy until you need real structure, relationships, permissions, and performance.
The ones that are powerful but come with a heavy config surface, fragile update paths, and a lot of "CMS ceremony".

MonkeysCMS is my attempt to take the best ideas from Drupal and WordPress and rebuild them in a modern, code-first way—on top of the MonkeysLegion framework.

If you like building systems (entities, schema, permissions, content modeling, tooling), I'd love your help shaping this into a real community CMS.

What MonkeysCMS is (in plain terms)

MonkeysCMS is a modern CMS where content types are PHP classes. No YAML stacks, no UI-first configuration as your source of truth.

The core ideas

Code-first entities with PHP attributes: define content types as typed PHP classes.
Auto-sync schema: enable a module → tables are created immediately (no migrations or extra CLI steps for schema updates).
True modularity: isolated modules with namespaces, dependencies, and lifecycle hooks.
Normalized relational database (with proper relationships), avoiding the classic EAV pain.
API-first: REST endpoints for CMS operations (content, users, permissions, taxonomy, menus, settings, modules…).
Modern PHP (8.4+) with strict types and modern patterns.

Current progress (what's already in the repo)

This isn't a blank README—the repository already documents and scaffolds several major CMS building blocks:

1) Modules + schema sync

Enabling a module triggers discovery of entity classes, reads their attributes, generates SQL, and executes schema creation.

2) Entity system (attributes + field types + relations)

There's an attribute-based model for ContentType, Field, Relation, and Id, plus a mapped set of field types.

3) RBAC inspired by Drupal (but simplified)

System roles and permission patterns are defined and documented, including auto-registration of entity permissions on module enable.

4) Taxonomy system (Drupal-like)

Vocabularies, hierarchical terms, and entity-term assignment are part of the documented design.

5) Menus, settings, CLI tooling, caching, themes

The README outlines endpoints and CLI commands (./monkeys ...), caching via MonkeysLegion-Cache, and a theme system driven by .mlc configuration.

And yes: it's early-stage—right now the GitHub repo shows 0 issues and 0 PRs, which means contributors can still heavily influence the architecture and conventions.

Why I'm inviting contributors now

Because this is the sweet spot:

The direction is clear (code-first, modular, relational, API-first).
The foundation exists.
The project hasn't ossified into "that's how it's always been".

If you've ever wished you could build a CMS with the structure of Drupal but the developer experience of modern frameworks, this is that moment.

Where you can contribute (high-impact areas)

Here are contribution tracks that would immediately move MonkeysCMS forward:

Backend / Core

Harden the schema generator (indexes, constraints, diffs, safe updates)
Entity hydration/serialization edge cases
Relations: many-to-many helpers, cascade rules, eager loading patterns
Permissions middleware + auditability (deny reasons, permission tracing)

Admin API & DX

Consistency: error formats, pagination conventions, filtering/sorting spec
API docs (OpenAPI), example clients, Postman collections
CLI improvements around module lifecycle and schema preview

Content modeling features

Revisions, publishing workflows, moderation states (the README already hints at publishable/revisionable concepts via attributes)
Media handling (image/file/gallery field types)

Themes & rendering

Improve the theme manager + template engine integration
Starter themes and real-world example templates

Tests

Unit + integration coverage (schema generation, permissions checks, taxonomy trees, CRUD flows)

Quick start (run it locally)

Requirements: PHP 8.4+, MySQL 8+ or SQLite, Composer 2.x.

git clone https://github.com/MonkeysCloud/MonkeysCMS.git
cd monkeyscms
composer install
cp .env.example .env
composer serve
# or
./monkeys serve

How to contribute

The current contribution flow is simple: fork → branch → PR.

If you want something easy to start with:

Pick one small improvement in docs or tests
Open a PR
We'll shape conventions together as we go

The vision (what we're building toward)

A CMS that feels like this:

You define content models like you define application code.
Enabling a module makes the system real immediately (schema + permissions + API).
You get "CMS power" (content types, taxonomy, menus, blocks, roles) without legacy complexity.

If that resonates, jump in.

Repo: MonkeysCloud/MonkeysCMS

Built on: MonkeysLegion Framework

Questions? Drop a comment below or open an issue on GitHub. Let's build something great together.

Slack: https://join.slack.com/t/monkeyslegion/shared_invite/zt-36jut3kqo-WCwOabVrVrhHBln4xhMATA

MonkeysLegion 1.0.8: From Side Project to Production-Ready PHP Ecosystem

Jorge Peraza — Sun, 23 Nov 2025 20:28:52 +0000

When I first introduced MonkeysLegion on the internet, it was “just” a new PHP 8 framework with a bold promise:

Let modern teams move from commit to cloud without the boilerplate.

Back then, that promise was mostly about vision. The core worked, but a lot was still in motion: APIs were evolving, packages were experimental, and I was shipping fast to prove the ideas.

Fast-forward to v1.0.8 of the framework (and beyond into 1.0.x), and MonkeysLegion has grown into a mature, modular ecosystem: a set of focused packages, a production-ready skeleton, batteries-included tooling, and opinionated patterns that have already been battle-tested in real projects.

This article is about that journey:

What MonkeysLegion is in practice

How it helps you ship production code faster
What changed from 1.0.0 to the 1.0.8+ line
Why I believe it’s now a solid choice for real apps
How you can contribute and help shape where it goes next

What is MonkeysLegion, really?

MonkeysLegion is a feather-light, modular PHP 8+ framework designed to bridge the gap between “micro-frameworks that make you build everything yourself” and “mega-frameworks that feel like a monolith.”

The official homepage describes it as:

“A lightweight, modular framework that lets modern teams move from commit to cloud without the boilerplate.”

In practical terms, a MonkeysLegion application is built on top of:

PSR-11 DI container with configuration-first definitions
PSR-7/15 HTTP stack (requests, responses, middleware, emitter)
An attribute-based router with auto-discovery (no giant route files)
Validation layer with DTO binding + attribute constraints
MLView component templating (Blade-style but framework-native)
CLI toolbox for migrations, cache, key-gen, scaffolding
An Entity → Migration SQL diff generator for schema evolution
GitHub

On top of that, the ecosystem includes first-party packages for auth, query builder & micro-ORM, files & storage, Stripe payments, logging, dev server with hot-reload, telemetry, and more.

Why another PHP framework?

This is the question I answered when announcing v1.0.0 on dev.to:

MonkeysLegion was built for teams who want lightning-fast performance without the heavyweight abstractions of legacy stacks.

The goal isn’t to “beat” Laravel or Symfony. The goal is to serve teams that:

Want fast startup with production-ready defaults
Prefer explicit configuration over magical conventions
Need cloud-native patterns (observability, rate-limiting, OpenAPI) baked in
Care about maintainable, typed code and clean separation of boundaries

MonkeysLegion wants you to move quickly without paying for that speed later in unmaintainable code.

From v1.0.0 to v1.0.8+: what actually matured?

Version numbers can be misleading. “1.0.0” is technically stable, but in most OSS projects 1.0.0 is when the real testing begins. That was true for MonkeysLegion as well.

Between 1.0.0 and 1.0.8+, a lot changed:

1. A real ecosystem of first-party packages

What started as a single repo has evolved into a set of focused, versioned packages, all published on Packagist under the monkeyscloud/monkeyslegion-* namespace.

Some highlights:

monkeyslegion-core – kernel, events, core helpers
Libraries.io
monkeyslegion-http & monkeyslegion-router – PSR-7/15 stack + attribute router
monkeyslegion-query – Query Builder & Micro-ORM, PDO-based, with advanced queries, transactions, repositories, pagination, streaming, and support for MySQL, PostgreSQL, SQLite
monkeyslegion-auth – drop-in JWT-based auth & authorization layer
monkeyslegion-files – file storage & uploads abstraction (local/S3/GCS)
monkeyslegion-dev-server – hot-reload dev server built on PHP’s native web server
monkeyslegion-logger – advanced logger using PSR-3 & Monolog, fully typed
monkeyslegion-stripe – first-class Stripe integration for payments and subscriptions

This modularization is a big part of “maturity”:

You can opt into only what you need.
Each package has its own versioning & changelog.
Bugs can be fixed and features shipped without destabilizing the framework.

2. A production-ready skeleton

The MonkeysLegion Skeleton repo is now the canonical way to start a project. It’s a “batteries-included” starter that wires together the DI container, HTTP stack, router, validation, rate-limiter, MLView templating, CLI, and swagger/OpenAPI out of the box.
GitHub

That means you can go from:

composer create-project "monkeyscloud/monkeyslegion-skeleton" my-app
cd my-app
php vendor/bin/ml serve

…to a running app with:

/ → home route
/docs → live Swagger UI
/openapi.json → generated OpenAPI 3.1 spec
Ready-to-extend config files for DI, routes, and environment

You don’t have to “assemble a framework” yourself; you start from something that has already been battle-tested in real projects, then customize.

3. Dev experience: the hot-reload dev server

One of the biggest jumps in DX has been the MonkeysLegion Dev Server (monkeyslegion-dev-server)

Instead of manually running php -S and restarting when files change, you get:

start, stop, restart, status commands
Zero configuration for standard MonkeysLegion apps
Two hot-reload modes:
- entr (recommended) for efficient file watching
- Built-in PHP watcher for environments where entr isn’t available

It’s a small thing, but it turns the framework into something that feels modern:
save → server restarts → refresh → done.

4. Database layer that grew up

The Query Builder & Micro-ORM (monkeyslegion-query) has probably seen the most action. Originally a simple fluent wrapper over PDO, it has matured into a package that can stand on its own:

Fluent, chainable API (select, join, where, groupBy, having, etc.)
Automatic parameter binding to prevent SQL injection
Transaction support including savepoints
Advanced queries: joins, subqueries, unions, CTEs
Built-in Repository pattern with typed entities
Streaming & chunking for large datasets
Pagination helpers

If you’ve ever bounced between “raw PDO” and “too heavy ORM”, this is meant to fit the sweet spot: expressive yet predictable.

How MonkeysLegion helps you develop faster

Let’s turn all this into concrete benefits for day-to-day development.

. 1. Clear separation of concerns

Because the framework is organized around PSR standards and explicit boundaries, your code tends to naturally fall into clean layers:

Actions / Controllers handle HTTP
Services encapsulate business logic
Repositories handle persistence via monkeyslegion-query
DTOs + Validators guard your input and output
Templates (MLView) render views

That makes it easier to:

Write unit tests for each layer
Swap implementations (e.g., DB driver, storage backend)
Onboard new team members (“here’s where we put X”)

2. A router that stays out of your way

The attribute-based router lets you define routes right next to your controllers, with typed signatures and middleware attributes.

A typical action might look like:

use MonkeysLegion\Http\Attributes\Route;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

final class HelloAction
{
    #[Route('GET', '/hello')]
    public function __invoke(ServerRequestInterface $request): ResponseInterface
    {
        $name = $request->getQueryParams()['name'] ?? 'world';

        return ml_view('hello', ['name' => $name]);
    }
}

No massive routing file. No “route caching dance.” Just attributes, auto-discovery, and type-safe handlers.

3. Built-in OpenAPI & documentation

Because the skeleton comes with OpenAPI 3.1 generation and Swagger UI, documenting your APIs isn’t an afterthought.

As you annotate your handlers and DTOs, the framework can produce machine-readable API specs, which means:

Better collaboration with frontend teams
Easier client generation
Less outdated docs

4. Cloud-native mindset from day one

From rate-limiting to telemetry, MonkeysLegion pushes you toward cloud-ready defaults:

Sliding-window rate limiter (IP + user buckets) baked into the skeleton
Clear HTTP and middleware boundaries (easy to integrate with gateways)
Logging & telemetry packages that play nicely with modern observability stacks

The result: your app is more prepared for real production traffic without heroic refactors.

Why 1.0.8+ feels “mature”

So, what does “maturity” mean in this context?

For MonkeysLegion, maturity at 1.0.8+ looks like:

Stable public APIs
- Core contracts and namespaces are no longer moving targets.
- SemVer is respected: breaking changes are either postponed or properly versioned.
Package ecosystem instead of a monolith
- Auth, Stripe, Files, Query, Dev Server, Logger, Telemetry, etc. all live in their own repos and versions.
Used in real projects (not just demos)
- The skeleton and core packages are already running production apps, which has driven fixes around performance, DX, and edge cases.
Tooling that feels cohesive
- Dev server, CLI, migrations, OpenAPI, auth, logging — all share the same design language and conventions.

MonkeysLegion has moved from “cool framework on paper” to “this is something you can actually bet a project on.”

Getting started in a few minutes

If you want to try it out, here’s the quickest path:

composer create-project "monkeyscloud/monkeyslegion-skeleton" my-app
cd my-app

# Start dev server (hot-reload if `entr` is installed)
composer serve

Then open http://127.0.0.1:8000 in your browser, and you should see the default skeleton app with docs and health routes ready to go

How to contribute (and why I’d love your help)

MonkeysLegion is MIT licensed and lives on GitHub at:

github.com/MonkeysCloud/MonkeysLegion-Skeleton
There are lots of ways to help, even if you don’t consider yourself a “framework author”:

Use it on a side project and open issues when you hit rough edges.
Contribute to docs, examples, and guides — these matter as much as code.
Help improve integrations (Stripe, queues, 3rd-party APIs).
Add starter templates: API-only, multi-tenant SaaS, headless CMS, etc.
Help with benchmarks, performance profiling, and comparisons.

If you’ve ever wanted to influence how a modern PHP framework feels — especially one that cares about both DX and cloud-native patterns — this is your chance to help shape it early, while it’s already stable enough to be useful.

Final thoughts

MonkeysLegion started as an experiment: what if a PHP framework could feel as modern and cloud-aware as the stacks we see in Node, Go, and modern JVM land — without giving up PHP’s strengths?

At 1.0.8+, it’s no longer just an experiment. It’s a practical, production-ready toolkit for teams who want:

Explicit architecture
Strong defaults
Real-world performance
And a framework that stays out of the way when it should

If that resonates with you, spin up the skeleton, break things, open issues, and send PRs. I’d love to see what you build with it — and how your feedback can push the 1.0.x line into something that serves the community even better.

Slack support

Everyone's welcome on the journey 🔥 This product will be unique, bouncing between high performance, high quality, and output!

Jorge Peraza — Tue, 28 Oct 2025 02:46:28 +0000

From Developing MonkeysLegion Framework to Building a Next-Gen CMS!

Marouane Amanar ・ Oct 27

#showdev #webdev #ai #career

Ship Production-Ready PHP in Record Time with MonkeysLegion

Jorge Peraza — Fri, 24 Oct 2025 01:32:12 +0000

🚀 Ship Production-Ready PHP in Record Time with MonkeysLegion

If you’re a PHP developer or part of a modern web-team shipping APIs, micro-services or full-blown back-ends, you’re likely well aware of the friction that comes from boilerplate setup, configuration chaos, and the endless round of “which router, which DI container, what dev-ops infra” decisions.

That’s exactly the problem we set out to solve with MonkeysLegion — a lightweight, modular PHP framework built to streamline your workflow from commit → cloud in minutes, not days.

🧠 Why MonkeysLegion?

🔧 Minimal setup, maximum output

From day one, MonkeysLegion gives you a blazing-fast router, a rock-solid dependency-injection container, a first-class CLI tool, and a zero-config Docker stack that’s ready for testing, observability and scaling.

“Cut setup from days to minutes — MonkeysLegion bundles everything wired for testing, observability, and scale on day one.”

— monkeyslegion.com

👥 Built for modern teams

MonkeysLegion isn’t just for solo hacks — it’s meant for agencies, shops, and internal dev teams who want consistency, speed and sanity.

✅ Clear structure so new joiners can hit the ground running

✅ Environment setup handled (via Docker) — less “works on my machine” drama

✅ Router + DI + CLI combo that plays nicely with tests, observability, and deployment pipelines

🧩 Feature-rich without being heavy

Out of the box:

Fast router (lean and expressive)
DI Container (clean, maintainable dependencies)
CLI for migrations, tasks, and seeding
Zero-config Docker stack (dev/test/prod parity)

Use it standalone or extend it with your favorite libraries — MonkeysLegion plays nice with everything.

⚙️ Getting Started

composer create-project "monkeyscloud/monkeyslegion-skeleton"

That’s it.
You’ll get a running skeleton pre-wired for routing, DI, and CLI.
Then:

Spin up the Docker environment
Define routes/controllers
Register your services in the DI container
Write your first test
Deploy using the same stack into production

Docs: https://monkeyslegion.com

💡 Example: Defining a Simple API Endpoint

// routes/api.php
$app->get('/users/{id}', function ($request, $response, array $args) {
    $userId = (int) $args['id'];

    /** @var \App\Service\UserService $userService */
    $userService = $this->get(UserService::class);
    $user = $userService->findUser($userId);

    return $response->withJson($user);
});

And the corresponding service might live in
src/Service/UserService.php under the DI container, keeping your architecture clean and testable.

🔍 Why This Approach Matters

🚀 Faster time to value

No more setup debates. Prototype, iterate, and deploy faster.

🧱 Consistency & maintainability

Clean structure → faster onboarding → easier reviews → predictable builds.

☁️ DevOps ready

A zero-config Docker stack ensures dev/test/production parity and smooth CI/CD integration.

🌱 Growing ecosystem

New components, CLI modules, and guides are published regularly on
➡️ monkeyslegion.com/blog

🧭 When Should You Use MonkeysLegion?

✅ When starting a new backend/API in PHP
✅ When your team needs an opinionated but flexible stack
✅ When you want built-in Docker support
✅ When you want to focus on features, not plumbing

Maybe skip it if:

You’re locked into another heavy framework (Laravel/Symfony)
You rely on very legacy PHP extensions not yet supported

🪄 Next Steps

Visit monkeyslegion.com
Explore the documentation & examples
Clone the skeleton and build a CRUD API
Join the community and share feedback

💬 In Summary

MonkeysLegion is more than another PHP framework — it’s a productivity-first ecosystem for modern teams.
If you’re ready to skip the boilerplate and focus on what actually matters, give it a try.

composer create-project "monkeyscloud/monkeyslegion-skeleton"

Happy shipping 🚀