AWS has changed one of the biggest assumptions about running web applications on Lambda.
Until now, developers often had to adapt a normal web server to Lambda’s event-based execution model.
That changed on October 12, 2026.
AWS launched Lambda Web Functions.
You can now run a standard HTTP server built with frameworks such as:
- Express
- Fastify
- Hono
- Next.js
- Other Node.js HTTP frameworks
The application listens on a port much like it would on a VPS or inside a Docker container.
AWS handles scaling, execution environments and optional multi-region distribution.
You can read the official AWS Lambda Web Functions announcement.
So does this mean businesses should stop using VPS servers and containers?
No.
It means developers now have another useful architecture option.
This guide compares AWS Lambda Web Functions, VPS hosting and container-based deployment so you can choose the right model for your application.
What Are AWS Lambda Web Functions?
Lambda Web Functions are a new AWS Lambda form factor built specifically for HTTP web applications.
The application runs as a normal web server.
It does not need to be rewritten as a traditional Lambda event handler.
AWS describes three Lambda execution models:
- Event Functions
- Web Functions
- Lambda MicroVMs
Each model serves a different workload.
Event Functions remain useful for asynchronous events and queues.
Web Functions target web servers and APIs.
MicroVMs are designed for isolated stateful sandbox environments.
Why Node.js Cloud Architecture Just Became More Flexible
Many Node.js applications are structured around a normal HTTP server.
For example:
const app = express();
app.get('/api/products', async (req, res) => {
res.json(products);
});
app.listen(3000);Traditionally, moving this kind of application to Lambda often required an adapter layer or architectural changes.
Web Functions reduce that difference.
AWS says the same standard HTTP framework can run directly as a Lambda Web Function.
This can make serverless migration much easier for existing Node.js applications.
What Frameworks Can Run on Lambda Web Functions?
AWS specifically mentions support for standard Node.js HTTP frameworks such as:
- Express
- Fastify
- Hono
- Next.js
The broader principle is simple.
If the framework can operate as a standard Node.js HTTP server, it may fit the Web Function model.
That makes this relevant to many modern SaaS products and APIs.
Lambda Web Functions Handle Multiple Concurrent Requests
Traditional Lambda execution has often been associated with one request per execution environment.
Web Functions change that assumption.
AWS says one Web Function environment can handle up to 128 concurrent requests.
This is important for web applications.
Incoming traffic can share warm execution environments rather than requiring a separate environment for every request.
That can improve efficiency for HTTP workloads.
AWS Introduced Active-CPU Billing
Web applications often spend time waiting.
For example:
- Waiting for a database
- Waiting for an external API
- Waiting for AI-model responses
- Streaming data
AWS says Web Functions meter CPU based on the time the application actively uses CPU resources.
Memory is billed while the execution environment exists.
This model can be attractive for I/O-heavy workloads.
AWS specifically highlights:
- Server-side rendering
- API backends
- AI inference endpoints
- Token streaming
What Is a VPS?
A VPS gives you a virtual server that remains available continuously.
You normally manage:
- Operating system
- Node.js
- Processes
- Reverse proxy
- Security updates
- Monitoring
- Scaling
A Node.js application might run through PM2 or systemd behind Nginx or another reverse proxy.
This architecture is simple and predictable.
For many applications, that simplicity is valuable.
What Is Container Hosting?
Containers package the application and its runtime dependencies together.
Docker is the most common example.
A container can run on platforms such as:
- A VPS
- AWS ECS
- AWS Fargate
- Kubernetes
- Other container platforms
Containers provide more deployment consistency than manually configuring every server.
They are especially useful when an application contains several independent services.
AWS Lambda Web Functions vs VPS
| Factor | Lambda Web Functions | VPS |
|---|---|---|
| Server management | Managed by AWS | Your responsibility |
| Scaling | Automatic | Manual or custom |
| Idle workload | Serverless model can help | Server remains running |
| Infrastructure control | More constrained | High |
| Deployment simplicity | Simple for supported apps | Simple with good tooling |
| Long-running server processes | Platform dependent | Strong fit |
| Predictable steady traffic | Can work well | Often very cost effective |
When Lambda Web Functions Are a Strong Choice
1. Traffic Is Unpredictable
Some applications receive very uneven traffic.
For example:
- Marketing campaigns
- Event websites
- New product launches
- Seasonal services
Automatic scaling can reduce the amount of capacity planning required.
2. You Do Not Want to Manage Servers
Server maintenance requires ongoing work.
Teams need to handle:
- Operating-system updates
- Node.js upgrades
- Process monitoring
- Disk management
- Scaling configuration
Serverless infrastructure moves more of that responsibility to AWS.
3. Your Application Is I/O Heavy
Many APIs spend more time waiting than computing.
A request may:
- Read from PostgreSQL.
- Call an external service.
- Return JSON.
Active-CPU billing may make this type of workload interesting for Web Functions.
4. You Need Global Deployment
AWS says Web Functions can be deployed to several regions through one deployment workflow.
Requests can then route toward a low-latency region using one global endpoint.
This removes some of the infrastructure traditionally required for multi-region applications.
When a VPS Is Still a Better Choice
A VPS is not outdated.
In fact, it remains one of the simplest hosting approaches for many applications.
1. Your Traffic Is Predictable
If a server runs continuously and receives steady traffic, a fixed-price VPS can be extremely cost effective.
You pay for the machine rather than every execution pattern.
2. You Want Full System Control
A VPS gives you control over:
- Operating system
- Processes
- Network configuration
- Storage
- Runtime
- Background workers
This flexibility can be useful for unusual applications.
3. Your Team Already Knows Server Operations
The operational burden matters less if your team already has:
- Deployment scripts
- Monitoring
- Backups
- Security procedures
Do not migrate to serverless simply because it is new.
When Containers Are the Better Choice
Containers become especially useful as architecture grows.
For example, your platform may contain:
- Frontend
- API gateway
- Authentication service
- Background workers
- Notification service
Each service can have its own container.
That provides deployment isolation and consistent environments.
Do You Need Microservices?
No.
Containerization does not automatically mean microservices.
A monolithic Node.js application can run perfectly well inside one Docker container.
Our guide to microservices architecture explains why startups should avoid unnecessary distributed-system complexity.
Can Next.js Run on AWS Lambda Web Functions?
AWS explicitly lists Next.js among the supported framework examples.
This makes Web Functions interesting for teams that want:
- Server-side rendering
- Dynamic routes
- Node.js server behaviour
- AWS-native infrastructure
However, framework compatibility does not automatically mean every Next.js application should migrate.
Review:
- Caching
- Static assets
- Image optimization
- Database connections
- Background tasks
The complete architecture still matters.
CloudFront Can Sit in Front of Web Functions
AWS supports Lambda Web Function endpoints as CloudFront origins.
This can create a useful architecture:
Customer → CloudFront → Lambda Web Function → Database/API.
Static assets can be served from CDN cache.
Dynamic requests go to the Web Function.
AWS also supports private-origin access through CloudFront Origin Access Control.
This can help keep the underlying Web Function endpoint inaccessible directly from the public internet.
Can Lambda Web Functions Access RDS?
Yes.
AWS says Web Functions support VPC connectivity at launch.
This means a Web Function can connect to resources such as:
- Amazon RDS
- Private APIs
- VPC services
However, database connection architecture still needs careful planning.
Large bursts of application concurrency can also create large numbers of database connections if the application is not designed correctly.
What About PostgreSQL Applications?
A Node.js application using PostgreSQL can fit several hosting models.
For example:
Option A: VPS + Node.js + PostgreSQL
Option B: Lambda Web Function + Amazon RDS PostgreSQL
Option C: Container + RDS PostgreSQL
No option is automatically correct.
The choice depends on:
- Traffic
- Team skills
- Scaling needs
- Budget
- Availability requirements
What About Background Jobs?
A web server should not necessarily handle every job.
For example, your application may need:
- Email delivery
- Report generation
- Image processing
- Scheduled tasks
Traditional Lambda Event Functions can remain useful for those workloads.
This allows teams to combine models.
You might use:
- Web Functions for API requests
- Event Functions for queues
- Containers for specialized long-running workers
Architecture does not need to choose one compute type for everything.
Can Lambda Web Functions Handle AI Streaming?
AWS specifically lists AI inference endpoints with streaming token responses as an example workload.
This is interesting for AI applications.
An AI endpoint often spends time:
- Waiting on a model
- Waiting on a database
- Streaming output
An active-CPU billing approach may suit this pattern.
However, always benchmark your actual workload.
Global Deployment Is Much Easier
Multi-region deployment traditionally involves:
- Deploying infrastructure in several regions
- Configuring traffic routing
- Managing versions
- Keeping configuration synchronized
AWS says the Lambda Web CLI can deploy the application to several regions and provide one global URL.
That can significantly simplify some globally distributed APIs.
Can You Do Canary Deployments?
Yes.
Lambda Web Functions use immutable revisions.
AWS allows traffic to be divided between revisions.
For example:
- 90% to the current release
- 10% to the new release
This allows teams to test a new production revision gradually.
If problems appear, traffic can be moved back.
Serverless Does Not Mean Zero Operations
This is important.
AWS manages the servers.
Your team still manages:
- Application security
- Dependencies
- Logging
- Database architecture
- Monitoring
- Environment variables
- Application bugs
Serverless reduces infrastructure operations.
It does not eliminate application operations.
Serverless Does Not Automatically Mean Cheaper
A workload that receives occasional traffic can fit serverless very well.
A continuously busy service may have different economics.
Therefore, compare the total cost of:
- Compute
- Memory
- Data transfer
- Database
- CDN
- Monitoring
- Operations
Do not compare only one line item.
VPS vs Lambda vs Containers: Decision Guide
| Scenario | Likely Starting Point |
|---|---|
| Small predictable business app | VPS |
| Traffic spikes heavily | Lambda Web Functions |
| Simple SaaS MVP | VPS or Web Functions |
| Several independently deployed services | Containers |
| Globally distributed HTTP API | Web Functions worth evaluating |
| Complex long-running workers | Containers / dedicated compute |
| AI streaming API | Web Functions worth benchmarking |
Do Not Migrate Just Because AWS Released Something New
Architecture migration carries cost and risk.
If your existing application:
- Runs reliably
- Costs little
- Scales adequately
- Is easy to maintain
then migration may provide very little value.
Technology decisions should solve business problems.
When Migration May Be Worth It
Web Functions become more interesting when you currently struggle with:
- Unpredictable traffic
- Server maintenance
- Multi-region complexity
- Idle infrastructure cost
- Scaling bottlenecks
Those are real architecture problems.
A new compute model may help.
How NRS Technologies Approaches Cloud Web Development
At NRS Technologies, hosting architecture starts with application requirements.
We work with modern technologies including:
- Next.js
- React
- Node.js
- Express
- PostgreSQL
- AWS
- Docker
Depending on the project, the correct deployment may be:
- A managed VPS
- Containers
- AWS Lambda
- A hybrid architecture
We do not recommend a distributed cloud architecture when a simple deployment can reliably solve the problem.
Planning a New Node.js or Next.js Application?
Before selecting hosting, estimate:
- Expected traffic
- Traffic spikes
- Database requirements
- Background jobs
- Latency requirements
- Countries served
- Team DevOps experience
Then compare the architectures.
You can review our selected web and cloud projects or learn more about NRS Technologies.
Ask NRS Technologies to design or review your Node.js cloud architecture →
Frequently Asked Questions
What are AWS Lambda Web Functions?
Lambda Web Functions are a new AWS Lambda form factor that allows standard Node.js HTTP applications to run on Lambda without being rewritten into traditional event handlers.
Can Express run directly on Lambda Web Functions?
Yes. AWS uses Express as an example and says standard frameworks including Express, Fastify, Hono and Next.js can run as Web Functions.
Can Next.js run on Lambda Web Functions?
Yes. AWS explicitly lists Next.js as a supported framework example for the Web Functions model.
How many requests can one Lambda Web Function environment handle?
AWS says one execution environment can handle up to 128 concurrent requests.
Are Lambda Web Functions better than a VPS?
Not always. Web Functions can be attractive for automatic scaling, global distribution and variable workloads. VPS hosting can remain simpler and cost effective for predictable steady workloads.
Do Lambda Web Functions support VPC access?
Yes. AWS says Web Functions support VPC connectivity, allowing them to access private AWS resources such as RDS databases.
Does NRS Technologies develop AWS-hosted Node.js applications?
Yes. NRS Technologies builds Next.js and Node.js applications and can design deployments using AWS, Docker, databases and other infrastructure based on project requirements.
Final Thoughts
AWS Lambda Web Functions make serverless hosting look much more familiar to normal Node.js developers.
You can run a standard web server.
You can handle concurrent HTTP requests.
You can deploy across regions.
And AWS handles much of the underlying infrastructure.
That is a meaningful improvement.
But it does not make VPS servers or containers obsolete.
The best architecture is still the one that solves your workload with the least unnecessary complexity.
If you are planning a Next.js, Node.js or SaaS application and are unsure whether to use Lambda, Docker or a VPS, contact NRS Technologies for an architecture review.