Contents:
- How CSS is evolving
- How CSS specifications differ
- Why there is no universal code for all browsers
- How standards development is organized and why standards are beneficial to everyone
- How specifications for CSS and HTML are written
- How developers can influence the development of specifications
- How specifications describe web accessibility
- Why there is no replacement for CSS
- Why no-code will not replace CSS
- How CSS will be developed soon.

Free Course: "Quick Start in Python"
Learn More
Nikita Dubko is the head of the development service, an active participant in the Web Standards podcast and the author of the popular account @dev_tip. His experience and knowledge in the field of web development make him a valuable expert, helping to disseminate relevant information and best practices in the industry. Nikita shares his experience and analysis of current trends, helping developers improve their skills and adapt to changes in technology. Links are an important element of web content, providing navigation and connections between pages. They help users easily find the information they need and navigate to other resources. Using links correctly is important to improve your site's visibility in search engines. Including relevant keywords in the anchor text of links increases the chances of high rankings in search results. It's also worth considering that links can be internal and external. Internal links help distribute the weight of pages within a site, while external links point to authoritative sources, increasing the trustworthiness of your content. Link optimization is an important step in SEO that can significantly impact traffic and conversion. In the early days of web technology, CSS offered a variety of formatting options, including XML-like formats and syntaxes that might seem non-standard. At the time, many developers used attributes in HTML code to define styles, and this was considered an acceptable approach. However, over time, web development practices have evolved, and using separate CSS files has become more preferable, as it simplifies style management and improves web page performance.
Since the introduction of CSS in 1996, the number of users and websites on the internet has increased significantly, and the tasks of web developers have become more complex. Previously, only headings, paragraphs, and links were used to create websites, but modern web resources require the implementation of more complex elements such as accordions, carousels, pop-ups, and animations. These new tools improve the user interface and increase user interaction, making websites more dynamic and attractive. Modern web development technologies open up new opportunities for creating interactive and functional solutions, which is an important aspect of successful online promotion.
Modern CSS offers a wide range of opportunities for web developers. There are specifications such as CSS Houdini, which significantly expand the functionality of style sheets. This makes it possible to integrate missing elements using Canvas and JavaScript. These innovations enable developers to create more complex and interactive interfaces, making web pages more engaging and functional.
How CSS Evolves
When CSS 1.0 was released, it was not very precise and did not always clearly define how browsers should display websites. In theory, everything looked correct, but in practice, interactions with various properties often led to display failures. Over time, the situation changed thanks to the introduction of web-platform-tests, which helped solve these problems, ensuring more stable and predictable browser interaction with CSS. As a result, developers received a tool for checking compatibility and improving code quality, which significantly simplified the process of creating and optimizing web pages.
The idea of creating tests began to develop in the 2000s. Although tests existed earlier, it was in the early 2000s that this topic began to be actively discussed in the professional community. It's worth noting that tests are often developed not by specification authors, but by the engineers who implement the functionality. This underscores the importance of hands-on experience in creating quality tests, which contributes to a better software development process.
With the advent of testing, browser developers, like those who apply the TDD (test-driven development) methodology, strive to ensure that tests pass with a minimum number of errors. This helps ensure high quality and stability of web applications and improves the user experience. Effective testing is a key element in the development process, as it helps identify and fix problems early, which ultimately leads to more reliable and performant browsers.
Despite the tests, some issues with gradient rendering in various browsers persist. To address these inconsistencies, changes and clarifications to the specifications are necessary. In the past, we used special mixins in Sass and Less that automatically selected the appropriate syntax for each browser. This has significantly simplified the development process and improved cross-browser compatibility. However, the relevance of this issue underscores the importance of constantly updating web development standards.
Thanks to Andrey Sitnik, Autoprefixer was created, significantly simplifying the process of automating prefixing. This solution allows developers to focus on more important tasks instead of manually searching for and implementing fixes for different browsers. Thus, Autoprefixer is becoming an indispensable tool in the web developer's arsenal, helping to speed up the development process and improve the quality of the final product.
In modern web development, CSS is no longer updated as a single, large standard. Instead, individual modules are constantly being added, creating a kind of "living" standard. The current standard is considered to be what is published on the official W3C pages for each module. Snapshots of the standard also exist, which contain module versions relevant for a specific year. This allows developers to stay up-to-date with the latest changes and use current CSS features in their projects.
This approach is convenient, but it leads to some modules barely evolving because users are satisfied with them. At the same time, the functionality and stability of other modules are subject to stricter industry expectations. This encourages more active updates and frequent releases of new versions. User expectations can be analyzed through discussions on browser GitHub pages, which allows us to understand which aspects require special attention and improvement.
CSS continues to evolve in line with industry needs, resulting in the emergence of new and interesting features. Let's look at a few examples that can significantly improve the work of web developers and designers. These innovations open up new opportunities for creating more flexible and aesthetically pleasing websites, enabling the implementation of modern design solutions and optimizing the user experience.
Modern monitors offer a significantly wider color gamut compared to previous generations. Previously, when cathode ray tubes were used, the color palette was limited to RGB. Today, monitors capable of reproducing rich color spaces are available, allowing users to maximize their potential. As a result, users can enjoy more vibrant and saturated colors, which is especially important for graphics and design professionals.
The latest updates to the specification make it possible to use color spaces in code, which is a significant advantage for designers and users. Developers can now implement these color spaces in their projects, and browsers can handle them correctly. This improves visual perception and expands the possibilities for creative design.
Previously, web pages were laid out using tables, which limited the flexibility and adaptability of design. Then, developers began using floats, which significantly improved the possibilities for arranging elements. With the advent of flexbox, CSS Grid, and multi-columns, web designers have gained powerful tools for creating more responsive and feature-rich interfaces. These modern approaches allow for the efficient organization of content, ensuring a user-friendly experience across a variety of devices.
Previously, rounding the corners of web design elements required resorting to tables and cutting PNG files into multiple pieces. Today, thanks to the CSS border-radius property, this process has become significantly simpler and more efficient. Using border-radius allows for quick and easy creation of rounded corners, improving the appearance of web pages and enhancing their aesthetic appeal. This property is supported by all modern browsers, making it a universal tool for web developers. Now, creating stylish and modern interfaces is within everyone's reach.
The advent of Flex and Grid has changed the approach to web development. Flexbox significantly expanded the possibilities for alignment and distribution of space between elements, while Grid offers more complex grid structures that are unavailable with tables. Container queries, long awaited, provide the ability to adapt elements based on the dimensions of their parent container, not just the viewport. This opens new horizons for creating adaptive and responsive designs.
Cascading layers are expected to be implemented in stable versions of browsers soon. This feature will allow web developers to more effectively manage the style cascade, rather than simply resolving conflicts. In addition, new container-based units are being developed. These units will be similar to vh and vw, but will be based on the width of the parent container. The introduction of cascading layers and new units will significantly simplify the process of creating adaptive and flexible designs, which is an important step in the development of web technologies.
With the release of HTTP/2, new loading methods have been introduced that allow multiple files to be combined into a single stream. This improves performance and reduces web page load times. Font specifications are also adapting to these new mechanisms, optimizing the process of loading and displaying fonts. Thus, the use of HTTP/2 facilitates more efficient resource management on websites, which in turn has a positive impact on user experience and SEO.
Masonry tiles are a prime example of modern web design. Previously, JavaScript libraries were used to implement them, but today a similar effect can be achieved by using CSS Grid. This simplifies the development process and improves website performance by eliminating the dependence on external scripts. Using CSS Grid to create Masonry tiles not only improves the user interface but also optimizes page loading, which has a positive impact on SEO.
The advent of CSS variables has made it possible to reuse and change design themes in real time. This has significantly changed the development process, as previously, loading a new theme often required a full page reload or providing the client with a new CSS style file that would replace the old one. Now developers can dynamically change styles, simplifying the creation of responsive and interactive web applications. Using CSS variables improves performance and usability, allowing you to quickly adapt your interface to different user preferences.
Currently, using pure CSS makes it easy to change the values of basic variables using media queries, resulting in automatic redrawing of elements. Previously, similar approaches resulted in the creation of cumbersome and complex classes, which complicated style maintenance and development. The new approach to CSS makes the process more organized and convenient, allowing developers to effectively manage styles and adapt them to different devices.
The examples presented above vividly illustrate the rapid evolution of CSS. With each update, new capabilities emerge, leading to updates to browser engines. This, in turn, facilitates the creation of new specifications and the transformation of variable-based design systems. The emergence of new approaches fundamentally changes the development process, making it more flexible and efficient. Developers can use the latest CSS features to create more complex and responsive interfaces, significantly improving the user experience. Thus, the evolution of CSS not only influences the technical aspects of web development, but also opens up new horizons for creative design solutions.
How CSS Specifications Difference
There are three versions of the CSS specification. The first CSS standard was quite compact and could easily be read in an evening. This basic standard laid the foundation for the further development of Cascading Style Sheets, which led to the emergence of more complex and functional versions. With each update, the specification expanded, adding new features and improving support for various devices and browsers.
With the release of CSS2, significantly more options became available to web developers. This standard introduced new properties, some of which were developed specifically for certain browsers. Over time, browsers began to implement their own unique properties, which led to the emergence of "browser-dependent" prefixes such as -webkit-text-stroke-outline-, -ms-, and -moz-. This created certain difficulties for developers, as they had to account for differences in feature support between different browsers.
When Apple faced the limitations of CSS, the company implemented features with the experimental -webkit- prefix into its WebKit engine. This decision encouraged the active use of these features by developers, who began creating websites optimized exclusively for the Safari browser. Later, the Chrome browser was developed based on this engine. Thus, the history of WebKit illustrates how innovations in one browser can influence the development of web technologies as a whole.
Companies developing alternative browsers urged developers to use their own prefixes, which resulted in the discontinuation of the -webkit- prefix. This caused many features to stop working correctly in other browsers: shadows disappeared on websites, and border-radius stopped displaying, leaving only text on a white background.
Over time, browsers abandoned the use of prefixes, but before that, most of them implemented support for some properties with the -webkit- prefix. This support was implemented in Firefox, Internet Explorer, Edge, and even the native Opera engine. Interestingly, such support contradicts the very essence of prefixes, which are designed to ensure the operation of properties exclusively in one specific browser.
Throughout the history of web development, Microsoft has always used prefixes, which caused difficulties for developers. In different versions of Internet Explorer, properties were displayed differently, which created additional difficulties. Internet Explorer 6 is especially memorable, which introduced many new features, but at the same time broke many old ones. To ensure the correct display of sites in this version of the browser, developers were forced to use special techniques known as "cheats". These solutions were necessary to adapt web pages to the requirements of Internet Explorer 6 and maintain their functionality.
While modern browsers largely support current web standards, it is important to exercise caution. When implementing new features, you should test their compatibility with the browsers your visitors use. To do this, you should analyze your site's visitor statistics. If a significant portion of users still use Internet Explorer, and these are not automated scripts, you will have to abandon the use of modern features and continue to support Internet Explorer. This will ensure that your site remains accessible to a wide audience and provides a positive user experience.
Trying to attract your audience to modern browsers certainly makes sense. However, if you are developing software for Russian accountants, it is worth considering that upgrading the outdated equipment they use to access the Internet may not be possible. This limitation must be taken into account when creating solutions that must be compatible with different browser versions and operating systems.
For some Internet Explorer users, 1% may seem like an insignificant error. However, for services with an audience of 200 million people, 1% means a loss of two million users, which is comparable to the population of a small country. Ignoring such an audience is impossible, so Internet Explorer support remains a critical task for many companies.
We are grateful to Andrey Sitnik's browserlist, which allows you to set user loss thresholds for your project. With the browserlist, autoprefixer will automatically add the necessary polyfills, ensuring your project's compatibility with various browser versions. Using this technology, you can improve the performance and accessibility of your web application without losing users who use outdated browsers.
On the one hand, you have the opportunity to make decisions independently, such as developing code that is compatible with older browsers. While this may limit the use of modern features, this approach avoids unnecessary work and simplifies project maintenance. Thus, developing code with compatibility in mind can be a smart choice for ensuring the stability and availability of web applications.
In my pet projects, I actively use the latest technologies, as my main audience is developers. It is unlikely that any of them use the outdated Internet Explorer, and I would be very surprised if they did. More often than not, they prefer browsers like Chrome or Firefox. At work, however, I cannot afford to use such innovations.
Let's return to the history of the development of CSS standards. The industry has reached the CSS3 stage, which no longer represents a single specification for all of CSS. It is rather a collection of different specifications, each focusing on certain aspects. The specifications are grouped by topic, and each of them is being worked on separately. For example, there is a specification describing how CSS works with fonts, as well as a separate specification dedicated to color management. This approach allows for more flexible and efficient development of web design technologies and improves user experience.
Why There Is No One Size Fits All Browsers
Despite advances in web standards and the end of browser competition, creating a universal code for all browsers remains a challenge. There are outdated browsers, as well as a variety of Asian browsers and old mobile devices that do not support modern technologies. Therefore, as long as such devices and browsers continue to be used, a universal solution remains elusive. This creates additional challenges for developers who need to consider a wide range of platforms and devices when creating web content.
According to Google statistics, the most popular phone is the Moto G4, not the iPhone. Despite having a weak processor and an outdated version of Android, users continue to use this device. Many modern features are not available on the Moto G4, but users still need access to sites and services optimized for their phone. This highlights the importance of developing responsive web design that takes into account the diversity of devices and their capabilities.
Vadim Makeev mentioned that the Opera browser team actively analyzed and fixed bugs, striving to ensure that their product complies with established standards. As a result, Opera followed specifications, while other browsers often ignored them. This commitment to standards underscores the importance of the quality and compatibility of web browsers, which directly impacts the user experience.
The primary way to improve accessibility in browsers remains the use of legacy layout standards. By building a website using tables, you can ensure that it displays correctly on most platforms. However, it is worth noting that this approach results in poorly maintainable code, which makes it difficult to integrate modern technologies such as React. Using older standards can temporarily solve compatibility issues, but in the long term, it is recommended to migrate to more modern layout methods to ensure better performance and responsiveness of the site.
The problem is that CSS has evolved significantly, and new features are not always worth implementing immediately after they are released. We've discussed this issue numerous times on the Web Standards podcast. For example, the new container queries feature is tempting to immediately start using it, but in practice, it's premature to implement it in production. Until Can I Use confirms that container queries work reliably in 95% of cases, it's best to hold off on using it. This approach will help avoid potential compatibility and performance issues.
Implementing new technologies and supporting legacy solutions often poses a dilemma for development teams. Developers are typically willing to do this only to implement a truly valuable feature. However, if a new feature only works for a small percentage of users, its usefulness is questionable. It's much more practical to strive to ensure a stable and high-quality product experience for all users. This allows for a harmonious and satisfying solution, which ultimately leads to increased customer loyalty and a better user experience.
Web content development has seen significant improvements recently. Previously, it was necessary to resort to various workarounds to ensure compatibility across browsers. However, tools such as browser lists, autoprefixers, and CSS plugins are now available that significantly simplify the process. This allows developers to use modern features that automatically work in current browsers, while ensuring correct display in older versions. These changes make web development more efficient and convenient.
There is no one-size-fits-all approach to CSS and JavaScript. Developers must consider the diversity of web browsers and their versions, as well as user behavior. This means that to achieve the best results, it is essential to analyze traffic statistics and adapt the code to specific conditions. Each project requires an individual approach, and only by considering the specifics of different browsers can a high-quality and functional web product be created.
How standards development works and why standards benefit everyone
Standards play a key role in web development, as they define how browsers should function and interact with content. The introduction of CSS3 and HTML5 standards in 2008 marked a significant milestone in the evolution of web technologies. This period was marked by active discussions among developers and browser makers, leading to a unified approach to adhering to the specifications. As a result, browsers abandoned the use of vendor prefixes, significantly improving the compatibility and predictability of web applications. Thus, standards became the foundation for the further development of web technologies and enhancing the user experience.
Although Chrome and Firefox browsers continue to make occasional changes without aligning with the general specifications, they justify their actions with security and privacy concerns. These "browser interventions" can affect the functionality and behavior of web applications, which in turn impacts the user experience. It is important to monitor updates and adapt to new requirements to ensure the security and privacy of data on the web.
As a developer, I am able to analyze specifications and draw conclusions about how a particular solution should function. However, this doesn't always guarantee that everything will work as intended. Often, browsers don't fully implement specifications, requiring additional verification. In such cases, it's important to consult resources such as Can I Use and browser repositories for up-to-date information on feature and functionality support. This helps avoid surprises and ensures more stable web applications.
The Grid specification is a comprehensive document describing the capabilities of Grid layout and contains numerous subcategories. For the most part, the core Grid features are supported by all popular browsers. However, some implementation details can cause difficulties when interacting with other CSS properties, leading to rendering errors in some browsers. This creates additional challenges for developers working with responsive and complex layouts. Therefore, it is important to test Grid layout on various platforms to ensure correct display and compatibility.
Each module has its own working group, and you can learn about their activities on the W3C (World Wide Web Consortium) website. W3C actively develops standards for web technologies and ensures their implementation, which helps improve the quality and compatibility of web content.

The W3C, or World Wide Web Consortium, comprises numerous working groups made up of representatives from browser companies, major universities, and research institutes. Members of these groups actively discuss API design and implementation with browser developers, helping to develop unified standards for web technologies. This collaboration promotes more compatible and functional web solutions, which in turn improves user experience and contributes to the development of the web as a whole.
Each working group is responsible for a specific module. In most cases, the team includes editors who develop and format the specification. Their job is to create clear, precise, and accurate text, supplemented with examples. Other specialists also participate in the discussions, but editors play a key role in shaping the specification and are responsible for it.
The list of W3C members can be found on the organization's official website. The association includes representatives of companies actively working in the field of web technologies, such as Google, Mozilla, Apple, Adobe, and other major players. These companies strive to ensure that the web functions efficiently and in a standardized manner. It is also worth noting that any company can apply to join the W3C, but a membership fee must be paid.
There is a separate category of invited experts, consisting of specialists who have made significant contributions to the development of web technologies. These experts are invited to the W3C, regardless of their affiliation, and have the opportunity to participate in the discussion of specifications. Their experience and knowledge contribute to the improvement of web standards and the development of new technologies.
Lia Verou is a leading expert in the field of CSS and the author of a world-renowned book on the topic. She has extensive experience, including giving numerous talks on CSS and SVG, as well as participating in the development of key specifications. While working at MIT, Lia previously worked freelance and was an invited expert in the CSS Working Group. Although she did not directly write the specifications, her contribution to their creation cannot be overstated. Leah actively promoted the Background & Borders, proposed various syntax options and conducted constructive discussions with browser developers, which significantly influenced the development of web design standards.

The experts regularly hold conference calls to discuss current issues. All discussions are recorded on GitHub, but I understand they also use IRC for communication. Although IRC is an outdated communication method, its logging system functions very effectively.
The experts also use classic email lists. Reading such materials requires patience, as our brains have adapted to modern instant messaging. Nevertheless, Sofia Valitova actively studies these lists and has a deep understanding of the topics discussed.
Working group members periodically gather for face-to-face meetings, where key decisions are made at a roundtable. These meetings are carefully documented by the secretary, ensuring transparency and an accountability of all issues discussed. Face-to-face meetings focus on analysis and further action on each specification. The frequency of such meetings is every six months or every year, which helps maintain the relevance and effectiveness of the group.
The committee determines who to invite to the meeting. A participant must be a person who has made significant contributions and directly influenced the development of CSS and HTML. Typically, experts, authors of well-known books and blogs are invited. It is important that their participation in the standards discussion is publicly visible and significant.
How CSS and HTML Specifications Are Written
A new CSS specification goes through a lengthy development process, which usually begins with the creation of explainer materials. Each browser has its own GitHub repositories where these explainer documents are hosted. Some developers limit themselves to a simple statement of the idea and a proposal for initial syntax. This allows the community to understand the main concepts and principles of the new specification and also facilitates further discussion and refinement.
Microsoft came up with the idea of developing solutions for foldable devices. The team analyzes which features need to be implemented and how to optimize work with such devices in CSS. This results in explanatory material that details the new capabilities, the required indentation for developers, and the corresponding media queries. Thus, the process begins with an internal hypothesis that guides further development.
The hypothesis is discussed at the W3C, where a decision is made on the advisability of including it in the next stage of the specification discussion and the possibility of adding it to the specification itself.
The specification includes several levels. The process begins with a draft—a rough version that is not mandatory for implementation in browsers. Next come candidate recommendations and standards. For a document to become a candidate recommendation, a working implementation in a browser must exist that can be tested and evaluated.
This process is quite complex. It requires not only clear agreement and a detailed description of the functionality, but also active collaboration with vendors. It is necessary to convince them of the need to implement the new feature and provide testing to confirm its effectiveness and functionality.
The Editorial Draft is the current version of the specification, which presents the latest features and updates. It should be noted that not all specification features are fully implemented. Therefore, it is recommended to regularly check the Can I Use platform, as browsers provide accurate data on implemented and unimplemented features. This will help developers stay up-to-date with the latest changes and make the best use of available technologies.
Different browsers have their own unique status platforms. For example, in Chrome, users can find tickets related to specific features, which indicate the stage of their implementation. This allows developers and users to track progress and stay up-to-date with support for various browser features.
How developers can influence the development of specifications
Developers should actively participate in the discussion of specifications, as this contributes to a better process for the development and adoption of new technologies. It's important to raise this topic in public spaces: share your opinions on podcasts, write articles, and make suggestions. Simply mentioning a stack specialist on Twitter may not be effective due to the overwhelming amount of information, and experts may overlook your message. However, it's worth noting that having a significant following, for example, 10,000 people, increases the chances of your message being noticed compared to an account with 200 followers. Participating in discussions not only increases the visibility of your ideas but can also contribute to improving the quality of developments in your field.
If a new feature breaks your code, it's important not to remain silent. Developers should report potential issues arising from the implementation of new features on their sites. One of the key principles of web specification development is ensuring backward compatibility. Each new specification must preserve the functionality of existing web resources. Developers are obligated to take this principle into account and adhere to it. However, it can often be difficult to identify potential problems without outside help.
You don't have to be a W3C member to present your idea. You can format your concept in explainer format and present it to vendors. Most resources are now available in open source, which simplifies the process of participating and making changes to projects. This means that even ordinary developers can easily contribute to the development of technologies and standards.
It's important to understand that you can't just show up at work and state your shortcomings, for example, that you're a beginner and have just completed a course. At the same time, you shouldn't claim that modern CSS specifications are incorrect and propose replacing them with JSON. In this case, you'll most likely be asked to justify your point of view or wait until you gain sufficient experience. It's important to approach such issues with respect for existing standards and demonstrate a willingness to learn and develop in your field.
Various web browsers have their own issue trackers, where the number of stars and likes for each proposal is recorded. Users can encourage their followers to rate stars and leave comments. If browser developers notice high interest in a particular proposal, this may encourage them to implement it. For example, if a thousand followers of a well-known blogger wholeheartedly support an idea, their activity will help move this feature up the priority list.
The specification is discussed on GitHub, and anyone can leave comments. Among my acquaintances, there are examples of successful participation. For example, Sofia Valitova collected numerous stars, which led to a fix for a long-standing browser bug. This is an impressive result, made possible by her careful study of the specification and identification of inconsistencies in browser behavior. Participating in such discussions not only helps improve technology but can also significantly increase the visibility of your contribution to the developer community.
I also had a similar experience. I collected examples of mathematical functions in CSS and demonstrated their usefulness. This material was submitted to an issue and became a compelling argument for implementing these features in projects.
How Specifications Describe Web Accessibility
Web content accessibility has recently attracted increasing attention due to the emergence of effective tools for its assessment. However, the concept of accessibility has existed from the very beginning of web standards development, and issues related to it were reflected in the first specifications. This underscores the importance of integrating accessibility into the content creation process, as it contributes to a better user experience for everyone. Developing accessible solutions not only meets legal requirements but also expands the audience, making content more inclusive.
Many outdated versions of specifications already contain sections addressing the challenges faced by blind users. An important aspect is the need to develop keyboard-accessible navigation. This underscores the significance of web content accessibility for all users, including people with disabilities. Implementing such solutions not only improves user experience but also promotes compliance with accessibility standards, which has a positive impact on SEO. Convenient tools for assessing website accessibility are now available. For example, you can open the accessibility tab in your browser to get an overview of your accessibility status. The Lighthouse tool now offers an audit that evaluates your website's accessibility. It's important to note that a maximum score of 100 does not guarantee absolute accessibility, while a score of 0 indicates complete inaccessibility. Assessing accessibility is an important aspect that must be considered to ensure the resource is usable for all categories of users.
Accessibility audits and tools like the popular Axe library have fostered the emergence of numerous accessibility ambassadors. These professionals actively discuss accessibility issues, organize courses, and build communities dedicated to the topic. As a result, new specifications are developed with an accessibility focus, making web content more inclusive for all users.
The introduction of new features on websites sometimes negatively impacts accessibility. For example, screen readers evolve more slowly than modern browsers. Many internet users use these programs to access websites rather than popular browsers like Chrome or Firefox. As a result, they experience issues with some web applications and websites. Resolving these issues requires software updates or the purchase of new devices. This is similar to the situation in web development: when a site is built using modern technologies, some users with older devices may experience difficulties accessing the content. Therefore, it is important to consider the accessibility and compatibility of web resources for all categories of users to ensure a high-quality user experience.
Why CSS is not expected to be replaced
Initially, CSS had many analogues that competed in the market. The developers of various specifications claimed that their solutions were the most effective, but ultimately, it was Cascading Style Sheets that came to dominate. CSS provided flexibility and ease of use in web design, which contributed to its widespread adoption and recognition as the standard for styling web pages.
We have been living with them for over 20 years, and we see no reason for radical changes. The modern web is largely focused on existing engines and parsers, as well as the huge number of sites created using CSS. These technologies continue to be the foundation of web development, ensuring stability and compatibility on the web.
Many websites currently lack the necessary support and remain online, running on outdated versions of WordPress. If significant changes to the CSS syntax occur, the question of what to do with these old resources will arise. Browsers will not be able to support both specifications—new and old—simultaneously, which will lead to an increase in the amount of work unnecessarily. This is why the current version of CSS remains acceptable for most web developers and users.
CSS has evolved significantly and is now used not only for the design of web pages but also for improving performance. While the syntax remains the same, modern practices allow you to use CSS for more efficient style management and reduce load times. This makes CSS an important tool not only for design but also for website optimization.
Judging by current trends, the situation is likely to persist. I'm not sure anything truly new will emerge: even if AR or VR web is on the horizon, backward compatibility with existing web technologies will still be required. New elements and features will likely be integrated using new CSS properties, ensuring a smooth transition and compatibility with existing web resources.
In my opinion, switching from CSS to another technology is only possible if an alternative web development platform emerges. However, the question arises: what will happen to the huge amount of useful content created over many years using CSS? Replacing technologies will require not only adapting existing resources but also carefully analyzing how to preserve and leverage the accumulated experience. It's important to remember that CSS has already become an integral part of web design and user experience. Therefore, any changes in this area must take into account existing content and ensure its accessibility for users.
Why no-code won't replace CSS
The no-code trend will not change the existing technology stack. There are rumors that senior no-code engineers earn significant sums. No-code solutions do represent a significant innovation, eliminating the need for developers to perform routine tasks. This positively impacts the development of junior developers, who can focus on more complex projects while the no-code specialist handles routine tasks. Thus, no-code not only optimizes workflows but also promotes the professional growth of programmers.
No single no-code solution can meet all business needs. When requests for custom development arise, the no-code engineer must revert to traditional programming and write code as before, which may lead to the need for workarounds.
The benefits of no-code solutions remain limited due to their one-size-fits-all approach, which impacts productivity. These tools are often not optimized for specific tasks and may require manual configuration, such as splitting into bundles. Achieving high productivity requires specialized teams that can tailor solutions to a project's unique requirements. Therefore, while no-code platforms simplify development, their effectiveness may be reduced compared to custom solutions built for specific business needs.
If no-code ever reaches this level, I wouldn't rule out the emergence of interesting solutions. Webpack used to require manual configuration, but now it has many built-in features. Similarly, we used to manually add prefixes using mixins, but now an autoprefixer does it for us. Technology continues to evolve, and with it, new specifications emerge that provide flexibility for solving various problems. This demonstrates that even with automated processes, there is always room for innovation and improvement.
No-code solutions and traditional development will coexist. I understand that it may be difficult for beginner web developers to adapt to this trend. The proliferation of no-code platforms like Tilda could indeed lead to a decrease in the number of openings for junior and middle-level developers. In some cases, creating a website using a website builder can be easier and faster than hiring a specialist. However, it's important to note that no-code solutions cannot completely replace professional developers. Complex projects and unique requirements still require skilled development. Therefore, despite the growing popularity of no-code, the role of experienced programmers will remain significant in the world of web development.
Modern businesses are increasingly recognizing the importance of an online presence. The demand for website developers is growing every year. For example, in Russia, a popular photo-sharing service used by many entrepreneurs to promote their products was shut down. In such a situation, businesses must seek alternative solutions, and creating their own websites is becoming a vital step to maintain competitiveness and attract customers. Web development offers new opportunities to implement ideas and expand your audience, making it an indispensable tool in the modern world.
The situation when you urgently need to create a website can be challenging. You must decide: use the Tilda platform or turn to a team of professionals who can develop an affordable online store and offer its support. Both options have their pros and cons. Tilda offers the ability to quickly create a website with ready-made templates, but may have limited functionality. At the same time, the development team will provide a personalized approach, creating a unique online store tailored to your requirements. The choice depends on your needs and budget, but it's important to remember that a high-quality website is an investment in the future of your business.
Market analysis can be challenging, but there is a growing interest in a thorough understanding of web technologies. This is a positive trend, as it helps reduce the number of low-quality products and improve the overall quality of web services. Increased demand for high-quality solutions will allow users to receive more efficient and reliable tools, which in turn will increase overall satisfaction and trust in web products.
It's indeed more difficult for modern juniors, and this is somewhat regrettable. I myself began my career in the labor market when knowing HTML and CSS was enough to be called a webmaster. Back then, knowledge of JavaScript was not required, and the focus was on layout. Now, the demands on entry-level specialists have increased significantly, and a successful career requires mastering a wider range of technologies.
In today's world, successfully starting a career requires knowledge of frameworks, the ability to deploy them, and run them in Docker. The knowledge threshold for getting your first job has increased significantly. This reflects the current reality. Previously, to be considered a physicist, it was enough to throw stones in an arc, but today you need to understand complex concepts such as string theory. Every profession is evolving, and this is a natural process.
How CSS will evolve in the near future
Browser developers have already announced their plans for the near future and promise to provide a report on the results achieved by the end of the year. The main areas of their work include:
Container queries provide the ability to use the dimensions of the parent element instead of the viewport dimensions. This opens new horizons for widget developers, as it allows for the creation of more responsive and context-sensitive interfaces. When this feature is implemented in browsers, developers will be able to integrate their elements not only through frames but in any format, depending on the properties of the container. This will significantly simplify the development process and improve the user experience, allowing for more flexible and responsive designs.
The parent selector in CSS. Just ten years ago, it was believed that its implementation was impossible, as it significantly slowed down the CSS parsing process and also complicated tree construction. However, it has become clear that it is indeed possible. The parent selector is a powerful tool that allows many tasks previously performed with JavaScript to be transferred directly to CSS. This is especially useful in situations where it is important to track changes in the layout structure. Previously, this required incorporating JavaScript, which would perform analysis and parsing, and then add the necessary classes. Now, using the parent selector, you can simplify and optimize the process of styling elements, making your code cleaner and more efficient.
CSS isolation in layers is a concept related to managing the levels of the cascade. The Layers directive is currently being developed, which will allow CSS to be embedded in named or unnamed modules and loaded before others. This will provide control over the cascade by determining the order in which styles are loaded into the parser. This approach will improve code organization and increase readability, and will also make it easier to work with dependencies between styles, which is especially important for large projects and team development.
I haven't tried implementing this myself yet, as no one has proposed a complete solution. However, the draft standards mention the possibility of closing styles within a module. This is one of the main problems faced by JavaScript developers. While Layers won't solve all the difficulties, it is at least a first attempt to address them.
Compatibility and cross-browser support are key aspects of web development. Browser teams are working hard to ensure compatibility with key developer-requested features. This year, significant attention has been paid to improving compatibility with CSS Grid, Flexbox, color schemes, and rendering. These improvements contribute to more stable web applications and simplify the process of creating responsive designs. Cross-browser compatibility updates help developers create high-quality, modern websites that display correctly across all popular browsers.

