At AWS Day Prague, Petr Svoboda — CEO of CodeNOW — demonstrated how fast modern development can be. In just 20 minutes, he built two microservices using Amazon Q and the CodeNOW platform.
Many enterprises are still hesitant to adopt microservices architecture, often viewing it as too complex, expensive, or time-consuming. The reality is that while microservices bring clear benefits, they also introduce challenges:
- Testing and deployment complexity
- Transitioning between on-premises and cloud environments
- Increased need for automation and monitoring
Unlike monolithic applications, where tasks like authentication, debugging, and disaster recovery are solved once, microservices require these tasks to be repeated for every service. Without automation, these repetitive demands quickly overwhelm developers and eat into valuable time that could instead be used to deliver business-driven features.
This is why infrastructure abstraction and automation are critical. By reducing the operational burden, enterprises can unlock the full potential of microservices — achieving scalability, faster delivery cycles, and improved developer productivity.
Build 2 Microservices in 20 Minutes
When developing a new digital solution, most enterprises face a similar challenge: managing complexity across multiple channels. Consider an omnichannel application — it may include:
- Three different front-ends (public, internal, and mobile)
- Different security deployments for each channel
- Multiple technology stacks
- Separate back-ends for front-ends (BFFs) to handle different protocols and integrations
Even with all this complexity, the business logic remains the same. It’s omnichannel — meaning the same data and processes must be available consistently across every touchpoint.
At AWS Day Prague, Petr Svoboda, CEO of CodeNOW, demonstrated how to simplify this. In just 20 minutes, he showcased a three-tier application:
- A front-end layer
- A back-end for front-end (BFF) layer
- A core back-end component
This live demo proved that with the right platform, such as CodeNOW, enterprises can rapidly build and deploy microservices-based applications, reduce operational overhead, and deliver consistent user experiences across every channel.
How to Increase Your Chances of On-Time Success
One of the biggest productivity killers in software development is unnecessary meetings. To overcome this, we follow a “share-nothing” approach — every developer works in a personal, cloud-based development environment. This setup allows full independence: you control the schema, test features in isolation, and stay productive whether you’re at home or working from a café in Thailand.
Our development environments typically leverage open-source stateful components, including:
- A back-end-for-front-end (BFF) exposing a REST API
- Kafka for messaging and event streaming
- PostgreSQL for data processing and storage
This cloud-native approach provides flexibility, autonomy, and faster iteration.
However, higher environments like staging and production require a more reliable foundation. Relying solely on open-source tools can introduce scalability and support challenges. That’s why we recommend transitioning to managed cloud services such as:
- AWS RDS for PostgreSQL
- Managed Kafka
These services offer built-in scalability, monitoring, and disaster recovery procedures supported by centralized teams — ensuring your applications remain resilient and production-ready.
For the demo, Petr used pre-recorded videos to illustrate creating a new application and environment, leveraging free components in Git repositories.
From Coding to Deployment: A Streamlined Workflow
A successful software delivery pipeline depends on a clear and repeatable workflow. At CodeNOW, the process typically includes:
- Coding
- Versioning
- Release management
- Deployment
- Testing
While bugs or underperformance can occur, modern observability tools — such as end-to-end code tracing — are essential for troubleshooting communication issues in microservices architectures. Once the application passes validation, it is promoted to staging, where it undergoes further observation, refinement, and readiness checks before production.
At AWS Day Prague, Petr Svoboda demonstrated how to set up a new development environment using a Kubernetes namespace on an available cluster. Each application component was initialized from a golden template, scaffolded to a Git repository, and configured with project-specific settings (for example, Maven group IDs for Java).
Following the 12-factor app principles, all connections to external services were tracked and dynamically replaced with the appropriate connection strings during deployment. This ensures smooth transitions between development, staging, and production environments, while maintaining consistency and scalability.
Building on a Managed Foundation
To ensure flexibility and independence, Petr set up a managed Kafka service restricted to the development environment, along with a personal PostgreSQL instance. This approach avoided dependency on corporate-wide upgrades and created the foundation for an application composed of two components, powered by CI/CD pipelines and a lightweight Python-based frontend.
The frontend was connected to the back-end-for-front-end (BFF) via deployment-specific endpoints. This design allowed independent development while maintaining clarity in deployment and connection management.
From Golden Templates to Functional Code
The process began with creating the application, environment, and two stateful components, all scaffolded from golden templates for Java and Python. Coding efforts focused on the frontend, where Petr — despite limited Python or frontend expertise — leveraged Amazon Q to generate the necessary code.
Key steps included:
- Updating the application file to render a form
- Establishing an external connection with the BFF
- Designing the backend service to return HTTP 200 for successful responses and HTTP 400 for form validation errors
Although the frontend wasn’t production-ready, it effectively supported debugging of the BFF and RBL components, accelerating development and testing.
Git-Centric Workflow with CI/CD
The entire workflow revolved around a Git repository, where code changes triggered CI pipelines either manually or automatically — supporting multiple coding styles such as Git Flow.
CodeNOW further streamlined the process by integrating with enterprise tools like GitHub Actions. This ensured:
- Seamless component management
- Consistent pipeline orchestration
- Enforced limited permissions for enhanced safety and security
Automating Releases and Validating Performance
The next steps in the workflow involve creating a release by satisfying all dependencies — such as Kafka and database connections — and synchronizing the state to the target environment using Argo. This process can be automated via APIs or Infrastructure as Code (IaC) tools like Terraform, with flexibility to use GitOps or manual configurations for demonstration purposes.
Centralized platform teams remain critical to this process, but they must also prepare for potential challenges in coordination and governance. In Petr Svoboda’s demo, a new release configuration was created for the three application components, validated by Argo CD, and successfully deployed.
To ensure reliability, load testing was performed using Amazon Q to generate a K6 script targeting the BFF REST endpoint. The results were monitored through pre-integrated, open-source observability tools such as Grafana, while logs and live tails provided deeper insights into component performance.
Key Takeaways from AWS Day Prague
Petr’s talk was filled with actionable lessons for building resilient and scalable software systems:
- Domain-Driven Design (DDD): ensures the right size and logical split of software assets
- Self-service platforms: minimize unnecessary communication between development and operations teams
- Immutable infrastructure: strengthens reliability and simplifies disaster recovery
- Integrated platforms (like CodeNOW): unify the developer experience across the entire software development lifecycle (SDLC)
Watch the demo video here.
